Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

79 files changed, 22090 insertions, 22090 deletions

diff --git a/contrib/python/setuptools/py2/.dist-info/METADATA b/contrib/python/setuptools/py2/.dist-info/METADATA
index be7cee6b32..f4a12783c7 100644
--- a/contrib/python/setuptools/py2/.dist-info/METADATA
+++ b/contrib/python/setuptools/py2/.dist-info/METADATA
@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.1 
 Name: setuptools
-Version: 44.1.1
+Version: 44.1.1 
 Summary: Easily download, build, install, upgrade, and uninstall Python packages
 Home-page: https://github.com/pypa/setuptools
 Author: Python Packaging Authority
@@ -18,37 +18,37 @@ Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.5
 Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.7 
+Classifier: Programming Language :: Python :: 3.8 
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Archiving :: Packaging
 Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Utilities
-Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7 
 Description-Content-Type: text/x-rst; charset=UTF-8
 Provides-Extra: certs
-Requires-Dist: certifi (==2016.9.26) ; extra == 'certs'
+Requires-Dist: certifi (==2016.9.26) ; extra == 'certs' 
 Provides-Extra: ssl
-Requires-Dist: wincertstore (==0.2) ; (sys_platform == "win32") and extra == 'ssl'
+Requires-Dist: wincertstore (==0.2) ; (sys_platform == "win32") and extra == 'ssl' 
 
 .. image:: https://img.shields.io/pypi/v/setuptools.svg
    :target: https://pypi.org/project/setuptools
 
-.. image:: https://img.shields.io/readthedocs/setuptools/latest.svg
+.. image:: https://img.shields.io/readthedocs/setuptools/latest.svg 
     :target: https://setuptools.readthedocs.io
 
-.. image:: https://img.shields.io/travis/pypa/setuptools/master.svg?label=Linux%20CI&logo=travis&logoColor=white
+.. image:: https://img.shields.io/travis/pypa/setuptools/master.svg?label=Linux%20CI&logo=travis&logoColor=white 
    :target: https://travis-ci.org/pypa/setuptools
 
-.. image:: https://img.shields.io/appveyor/ci/pypa/setuptools/master.svg?label=Windows%20CI&logo=appveyor&logoColor=white
-   :target: https://ci.appveyor.com/project/pypa/setuptools/branch/master
-
-.. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white
-   :target: https://codecov.io/gh/pypa/setuptools
-
-.. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat
-   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme
+.. image:: https://img.shields.io/appveyor/ci/pypa/setuptools/master.svg?label=Windows%20CI&logo=appveyor&logoColor=white 
+   :target: https://ci.appveyor.com/project/pypa/setuptools/branch/master 
 
+.. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white 
+   :target: https://codecov.io/gh/pypa/setuptools 
+ 
+.. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat 
+   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme 
+ 
 .. image:: https://img.shields.io/pypi/pyversions/setuptools.svg
 
 See the `Installation Instructions
@@ -62,22 +62,22 @@ Bug reports and especially tested patches may be
 submitted directly to the `bug tracker
 <https://github.com/pypa/setuptools/issues>`_.
 
-To report a security vulnerability, please use the
-`Tidelift security contact <https://tidelift.com/security>`_.
-Tidelift will coordinate the fix and disclosure.
-
-
-For Enterprise
-==============
-
-Available as part of the Tidelift Subscription.
-
-Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.
-
-`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_.
-
+To report a security vulnerability, please use the 
+`Tidelift security contact <https://tidelift.com/security>`_. 
+Tidelift will coordinate the fix and disclosure. 
+
+ 
+For Enterprise 
+============== 
+ 
+Available as part of the Tidelift Subscription. 
+ 
+Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. 
+ 
+`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_. 
+ 
 Code of Conduct
-===============
+=============== 
 
 Everyone interacting in the setuptools project's codebases, issue trackers,
 chat rooms, and mailing lists is expected to follow the
diff --git a/contrib/python/setuptools/py2/.dist-info/entry_points.txt b/contrib/python/setuptools/py2/.dist-info/entry_points.txt
index e668270fa1..23a5218183 100644
--- a/contrib/python/setuptools/py2/.dist-info/entry_points.txt
+++ b/contrib/python/setuptools/py2/.dist-info/entry_points.txt
@@ -1,6 +1,6 @@
 [console_scripts]
 easy_install = setuptools.command.easy_install:main
-easy_install-3.8 = setuptools.command.easy_install:main
+easy_install-3.8 = setuptools.command.easy_install:main 
 
 [distutils.commands]
 alias = setuptools.command.alias:alias
@@ -58,12 +58,12 @@ namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
 requires.txt = setuptools.command.egg_info:write_requirements
 top_level.txt = setuptools.command.egg_info:write_toplevel_names
 
-[setuptools.finalize_distribution_options]
-2to3_doctests = setuptools.dist:Distribution._finalize_2to3_doctests
-features = setuptools.dist:Distribution._finalize_feature_opts
-keywords = setuptools.dist:Distribution._finalize_setup_keywords
-parent_finalize = setuptools.dist:_Distribution.finalize_options
-
+[setuptools.finalize_distribution_options] 
+2to3_doctests = setuptools.dist:Distribution._finalize_2to3_doctests 
+features = setuptools.dist:Distribution._finalize_feature_opts 
+keywords = setuptools.dist:Distribution._finalize_setup_keywords 
+parent_finalize = setuptools.dist:_Distribution.finalize_options 
+ 
 [setuptools.installation]
 eggsecutable = setuptools.command.easy_install:bootstrap
 
diff --git a/contrib/python/setuptools/py2/.dist-info/top_level.txt b/contrib/python/setuptools/py2/.dist-info/top_level.txt
index 4577c6a795..8674022814 100644
--- a/contrib/python/setuptools/py2/.dist-info/top_level.txt
+++ b/contrib/python/setuptools/py2/.dist-info/top_level.txt
@@ -1,3 +1,3 @@
-easy_install
-pkg_resources
-setuptools
+easy_install 
+pkg_resources 
+setuptools 
diff --git a/contrib/python/setuptools/py2/LICENSE b/contrib/python/setuptools/py2/LICENSE
index 6e0693b4b0..f6f9c47956 100644
--- a/contrib/python/setuptools/py2/LICENSE
+++ b/contrib/python/setuptools/py2/LICENSE
@@ -1,19 +1,19 @@
-Copyright (C) 2016 Jason R Coombs <jaraco@jaraco.com>
-
-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.
+Copyright (C) 2016 Jason R Coombs <jaraco@jaraco.com> 
+ 
+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. 
diff --git a/contrib/python/setuptools/py2/README.rst b/contrib/python/setuptools/py2/README.rst
index da0549a98a..7370f12b54 100644
--- a/contrib/python/setuptools/py2/README.rst
+++ b/contrib/python/setuptools/py2/README.rst
@@ -1,51 +1,51 @@
-.. image:: https://img.shields.io/pypi/v/setuptools.svg
-   :target: https://pypi.org/project/setuptools
-
-.. image:: https://img.shields.io/readthedocs/setuptools/latest.svg
-    :target: https://setuptools.readthedocs.io
-
-.. image:: https://img.shields.io/travis/pypa/setuptools/master.svg?label=Linux%20CI&logo=travis&logoColor=white
-   :target: https://travis-ci.org/pypa/setuptools
-
-.. image:: https://img.shields.io/appveyor/ci/pypa/setuptools/master.svg?label=Windows%20CI&logo=appveyor&logoColor=white
-   :target: https://ci.appveyor.com/project/pypa/setuptools/branch/master
-
-.. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white
-   :target: https://codecov.io/gh/pypa/setuptools
-
-.. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat
-   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme
-
-.. image:: https://img.shields.io/pypi/pyversions/setuptools.svg
-
-See the `Installation Instructions
-<https://packaging.python.org/installing/>`_ in the Python Packaging
-User's Guide for instructions on installing, upgrading, and uninstalling
-Setuptools.
-
-Questions and comments should be directed to the `distutils-sig
-mailing list <http://mail.python.org/pipermail/distutils-sig/>`_.
-Bug reports and especially tested patches may be
-submitted directly to the `bug tracker
-<https://github.com/pypa/setuptools/issues>`_.
-
-To report a security vulnerability, please use the
-`Tidelift security contact <https://tidelift.com/security>`_.
-Tidelift will coordinate the fix and disclosure.
-
-
-For Enterprise
-==============
-
-Available as part of the Tidelift Subscription.
-
-Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.
-
-`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_.
-
-Code of Conduct
-===============
-
-Everyone interacting in the setuptools project's codebases, issue trackers,
-chat rooms, and mailing lists is expected to follow the
-`PyPA Code of Conduct <https://www.pypa.io/en/latest/code-of-conduct/>`_.
+.. image:: https://img.shields.io/pypi/v/setuptools.svg 
+   :target: https://pypi.org/project/setuptools 
+ 
+.. image:: https://img.shields.io/readthedocs/setuptools/latest.svg 
+    :target: https://setuptools.readthedocs.io 
+ 
+.. image:: https://img.shields.io/travis/pypa/setuptools/master.svg?label=Linux%20CI&logo=travis&logoColor=white 
+   :target: https://travis-ci.org/pypa/setuptools 
+ 
+.. image:: https://img.shields.io/appveyor/ci/pypa/setuptools/master.svg?label=Windows%20CI&logo=appveyor&logoColor=white 
+   :target: https://ci.appveyor.com/project/pypa/setuptools/branch/master 
+ 
+.. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white 
+   :target: https://codecov.io/gh/pypa/setuptools 
+ 
+.. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat 
+   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme 
+ 
+.. image:: https://img.shields.io/pypi/pyversions/setuptools.svg 
+ 
+See the `Installation Instructions 
+<https://packaging.python.org/installing/>`_ in the Python Packaging 
+User's Guide for instructions on installing, upgrading, and uninstalling 
+Setuptools. 
+ 
+Questions and comments should be directed to the `distutils-sig 
+mailing list <http://mail.python.org/pipermail/distutils-sig/>`_. 
+Bug reports and especially tested patches may be 
+submitted directly to the `bug tracker 
+<https://github.com/pypa/setuptools/issues>`_. 
+ 
+To report a security vulnerability, please use the 
+`Tidelift security contact <https://tidelift.com/security>`_. 
+Tidelift will coordinate the fix and disclosure. 
+ 
+ 
+For Enterprise 
+============== 
+ 
+Available as part of the Tidelift Subscription. 
+ 
+Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. 
+ 
+`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_. 
+ 
+Code of Conduct 
+=============== 
+ 
+Everyone interacting in the setuptools project's codebases, issue trackers, 
+chat rooms, and mailing lists is expected to follow the 
+`PyPA Code of Conduct <https://www.pypa.io/en/latest/code-of-conduct/>`_. 
diff --git a/contrib/python/setuptools/py2/pkg_resources/__init__.py b/contrib/python/setuptools/py2/pkg_resources/__init__.py
index 649a2ce651..2ea16f11fb 100644
--- a/contrib/python/setuptools/py2/pkg_resources/__init__.py
+++ b/contrib/python/setuptools/py2/pkg_resources/__init__.py
@@ -34,13 +34,13 @@ import platform
 import collections
 import plistlib
 import email.parser
-import errno
+import errno 
 import tempfile
 import textwrap
 import itertools
-import inspect
-import ntpath
-import posixpath
+import inspect 
+import ntpath 
+import posixpath 
 from pkgutil import get_importer
 
 try:
@@ -49,14 +49,14 @@ except ImportError:
     # Python 3.2 compatibility
     import imp as _imp
 
-try:
-    FileExistsError
-except NameError:
-    FileExistsError = OSError
-
-from pkg_resources.extern import six
-from pkg_resources.extern.six.moves import urllib, map, filter
+try: 
+    FileExistsError 
+except NameError: 
+    FileExistsError = OSError 
 
+from pkg_resources.extern import six 
+from pkg_resources.extern.six.moves import urllib, map, filter 
+ 
 # capture these to bypass sandboxing
 from os import utime
 try:
@@ -76,45 +76,45 @@ try:
 except ImportError:
     importlib_machinery = None
 
-from . import py31compat
-from pkg_resources.extern import appdirs
-from pkg_resources.extern import packaging
-__import__('pkg_resources.extern.packaging.version')
-__import__('pkg_resources.extern.packaging.specifiers')
-__import__('pkg_resources.extern.packaging.requirements')
-__import__('pkg_resources.extern.packaging.markers')
-
-
-__metaclass__ = type
-
-
-if (3, 0) < sys.version_info < (3, 5):
-    raise RuntimeError("Python 3.5 or later is required")
-
-if six.PY2:
-    # Those builtin exceptions are only defined in Python 3
-    PermissionError = None
-    NotADirectoryError = None
-
+from . import py31compat 
+from pkg_resources.extern import appdirs 
+from pkg_resources.extern import packaging 
+__import__('pkg_resources.extern.packaging.version') 
+__import__('pkg_resources.extern.packaging.specifiers') 
+__import__('pkg_resources.extern.packaging.requirements') 
+__import__('pkg_resources.extern.packaging.markers') 
+
+
+__metaclass__ = type 
+ 
+ 
+if (3, 0) < sys.version_info < (3, 5): 
+    raise RuntimeError("Python 3.5 or later is required") 
+ 
+if six.PY2: 
+    # Those builtin exceptions are only defined in Python 3 
+    PermissionError = None 
+    NotADirectoryError = None 
+ 
 # declare some globals that will be defined later to
 # satisfy the linters.
 require = None
 working_set = None
-add_activation_listener = None
-resources_stream = None
-cleanup_resources = None
-resource_dir = None
-resource_stream = None
-set_extraction_path = None
-resource_isdir = None
-resource_string = None
-iter_entry_points = None
-resource_listdir = None
-resource_filename = None
-resource_exists = None
-_distribution_finders = None
-_namespace_handlers = None
-_namespace_packages = None
+add_activation_listener = None 
+resources_stream = None 
+cleanup_resources = None 
+resource_dir = None 
+resource_stream = None 
+set_extraction_path = None 
+resource_isdir = None 
+resource_string = None 
+iter_entry_points = None 
+resource_listdir = None 
+resource_filename = None 
+resource_exists = None 
+_distribution_finders = None 
+_namespace_handlers = None 
+_namespace_packages = None 
 
 
 class PEP440Warning(RuntimeWarning):
@@ -126,9 +126,9 @@ class PEP440Warning(RuntimeWarning):
 
 def parse_version(v):
     try:
-        return packaging.version.Version(v)
+        return packaging.version.Version(v) 
     except packaging.version.InvalidVersion:
-        return packaging.version.LegacyVersion(v)
+        return packaging.version.LegacyVersion(v) 
 
 
 _state_vars = {}
@@ -240,9 +240,9 @@ __all__ = [
     'register_finder', 'register_namespace_handler', 'register_loader_type',
     'fixup_namespace_packages', 'get_importer',
 
-    # Warnings
-    'PkgResourcesDeprecationWarning',
-
+    # Warnings 
+    'PkgResourcesDeprecationWarning', 
+ 
     # Deprecated/backward compatibility only
     'run_main', 'AvailableDistributions',
 ]
@@ -333,7 +333,7 @@ class UnknownExtra(ResolutionError):
 
 _provider_factories = {}
 
-PY_MAJOR = '{}.{}'.format(*sys.version_info)
+PY_MAJOR = '{}.{}'.format(*sys.version_info) 
 EGG_DIST = 3
 BINARY_DIST = 2
 SOURCE_DIST = 1
@@ -390,17 +390,17 @@ def get_build_platform():
     XXX Currently this is the same as ``distutils.util.get_platform()``, but it
     needs some hacks for Linux and Mac OS X.
     """
-    from sysconfig import get_platform
+    from sysconfig import get_platform 
 
     plat = get_platform()
     if sys.platform == "darwin" and not plat.startswith('macosx-'):
         try:
             version = _macosx_vers()
             machine = os.uname()[4].replace(" ", "_")
-            return "macosx-%d.%d-%s" % (
-                int(version[0]), int(version[1]),
-                _macosx_arch(machine),
-            )
+            return "macosx-%d.%d-%s" % ( 
+                int(version[0]), int(version[1]), 
+                _macosx_arch(machine), 
+            ) 
         except ValueError:
             # if someone is running a non-Mac darwin system, this will fall
             # through to the default implementation
@@ -550,7 +550,7 @@ class IResourceProvider(IMetadataProvider):
         """List of resource names in the directory (like ``os.listdir()``)"""
 
 
-class WorkingSet:
+class WorkingSet: 
     """A collection of active distributions on sys.path (or a similar list)"""
 
     def __init__(self, entries=None):
@@ -650,12 +650,12 @@ class WorkingSet:
         distributions in the working set, otherwise only ones matching
         both `group` and `name` are yielded (in distribution order).
         """
-        return (
-            entry
-            for dist in self
-            for entry in dist.get_entry_map(group).values()
-            if name is None or name == entry.name
-        )
+        return ( 
+            entry 
+            for dist in self 
+            for entry in dist.get_entry_map(group).values() 
+            if name is None or name == entry.name 
+        ) 
 
     def run_script(self, requires, script_name):
         """Locate distribution for `requires` and run `script_name` script"""
@@ -724,8 +724,8 @@ class WorkingSet:
         already-installed distribution; it should return a ``Distribution`` or
         ``None``.
 
-        Unless `replace_conflicting=True`, raises a VersionConflict exception
-        if
+        Unless `replace_conflicting=True`, raises a VersionConflict exception 
+        if 
         any requirements are found on the path that have the correct name but
         the wrong version.  Otherwise, if an `installer` is supplied it will be
         invoked to obtain the correct version of the requirement and activate
@@ -777,10 +777,10 @@ class WorkingSet:
                             # distribution
                             env = Environment([])
                             ws = WorkingSet([])
-                    dist = best[req.key] = env.best_match(
-                        req, ws, installer,
-                        replace_conflicting=replace_conflicting
-                    )
+                    dist = best[req.key] = env.best_match( 
+                        req, ws, installer, 
+                        replace_conflicting=replace_conflicting 
+                    ) 
                     if dist is None:
                         requirers = required_by.get(req, None)
                         raise DistributionNotFound(req, requirers)
@@ -804,8 +804,8 @@ class WorkingSet:
         # return list of distros to activate
         return to_activate
 
-    def find_plugins(
-            self, plugin_env, full_env=None, installer=None, fallback=True):
+    def find_plugins( 
+            self, plugin_env, full_env=None, installer=None, fallback=True): 
         """Find all activatable distributions in `plugin_env`
 
         Example usage::
@@ -956,11 +956,11 @@ class _ReqExtras(dict):
         return not req.marker or any(extra_evals)
 
 
-class Environment:
+class Environment: 
     """Searchable snapshot of distributions on a search path"""
 
-    def __init__(
-            self, search_path=None, platform=get_supported_platform(),
+    def __init__( 
+            self, search_path=None, platform=get_supported_platform(), 
             python=PY_MAJOR):
         """Snapshot distributions available on a search path
 
@@ -971,7 +971,7 @@ class Environment:
         `platform` is an optional string specifying the name of the platform
         that platform-specific distributions must be compatible with.  If
         unspecified, it defaults to the current platform.  `python` is an
-        optional string naming the desired version of Python (e.g. ``'3.6'``);
+        optional string naming the desired version of Python (e.g. ``'3.6'``); 
         it defaults to the current version.
 
         You may explicitly set `platform` (and/or `python`) to ``None`` if you
@@ -990,12 +990,12 @@ class Environment:
         requirements specified when this environment was created, or False
         is returned.
         """
-        py_compat = (
-            self.python is None
-            or dist.py_version is None
-            or dist.py_version == self.python
-        )
-        return py_compat and compatible_platforms(dist.platform, self.platform)
+        py_compat = ( 
+            self.python is None 
+            or dist.py_version is None 
+            or dist.py_version == self.python 
+        ) 
+        return py_compat and compatible_platforms(dist.platform, self.platform) 
 
     def remove(self, dist):
         """Remove `dist` from the environment"""
@@ -1036,8 +1036,8 @@ class Environment:
                 dists.append(dist)
                 dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
 
-    def best_match(
-            self, req, working_set, installer=None, replace_conflicting=False):
+    def best_match( 
+            self, req, working_set, installer=None, replace_conflicting=False): 
         """Find distribution best matching `req` and usable on `working_set`
 
         This calls the ``find(req)`` method of the `working_set` to see if a
@@ -1050,12 +1050,12 @@ class Environment:
         calling the environment's ``obtain(req, installer)`` method will be
         returned.
         """
-        try:
-            dist = working_set.find(req)
-        except VersionConflict:
-            if not replace_conflicting:
-                raise
-            dist = None
+        try: 
+            dist = working_set.find(req) 
+        except VersionConflict: 
+            if not replace_conflicting: 
+                raise 
+            dist = None 
         if dist is not None:
             return dist
         for dist in self[req.key]:
@@ -1172,8 +1172,8 @@ class ResourceManager:
         tmpl = textwrap.dedent("""
             Can't extract file(s) to egg cache
 
-            The following error occurred while trying to extract file(s)
-            to the Python egg cache:
+            The following error occurred while trying to extract file(s) 
+            to the Python egg cache: 
 
               {old_exc}
 
@@ -1181,9 +1181,9 @@ class ResourceManager:
 
               {cache_path}
 
-            Perhaps your account does not have write access to this directory?
-            You can change the cache directory by setting the PYTHON_EGG_CACHE
-            environment variable to point to an accessible directory.
+            Perhaps your account does not have write access to this directory? 
+            You can change the cache directory by setting the PYTHON_EGG_CACHE 
+            environment variable to point to an accessible directory. 
             """).lstrip()
         err = ExtractionError(tmpl.format(**locals()))
         err.manager = self
@@ -1208,7 +1208,7 @@ class ResourceManager:
         target_path = os.path.join(extract_path, archive_name + '-tmp', *names)
         try:
             _bypass_ensure_directory(target_path)
-        except Exception:
+        except Exception: 
             self.extraction_error()
 
         self._warn_unsafe_extraction_path(extract_path)
@@ -1233,13 +1233,13 @@ class ResourceManager:
             return
         mode = os.stat(path).st_mode
         if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
-            msg = (
-                "%s is writable by group/others and vulnerable to attack "
+            msg = ( 
+                "%s is writable by group/others and vulnerable to attack " 
                 "when "
                 "used with get_resource_filename. Consider a more secure "
                 "location (set with .set_extraction_path or the "
-                "PYTHON_EGG_CACHE environment variable)." % path
-            )
+                "PYTHON_EGG_CACHE environment variable)." % path 
+            ) 
             warnings.warn(msg, UserWarning)
 
     def postprocess(self, tempname, filename):
@@ -1403,30 +1403,30 @@ class NullProvider:
     def has_resource(self, resource_name):
         return self._has(self._fn(self.module_path, resource_name))
 
-    def _get_metadata_path(self, name):
-        return self._fn(self.egg_info, name)
-
+    def _get_metadata_path(self, name): 
+        return self._fn(self.egg_info, name) 
+ 
     def has_metadata(self, name):
-        if not self.egg_info:
-            return self.egg_info
-
-        path = self._get_metadata_path(name)
-        return self._has(path)
+        if not self.egg_info: 
+            return self.egg_info 
 
+        path = self._get_metadata_path(name) 
+        return self._has(path) 
+ 
     def get_metadata(self, name):
         if not self.egg_info:
             return ""
-        path = self._get_metadata_path(name)
-        value = self._get(path)
-        if six.PY2:
-            return value
-        try:
-            return value.decode('utf-8')
-        except UnicodeDecodeError as exc:
-            # Include the path in the error message to simplify
-            # troubleshooting, and without changing the exception type.
-            exc.reason += ' in {} file at path: {}'.format(name, path)
-            raise
+        path = self._get_metadata_path(name) 
+        value = self._get(path) 
+        if six.PY2: 
+            return value 
+        try: 
+            return value.decode('utf-8') 
+        except UnicodeDecodeError as exc: 
+            # Include the path in the error message to simplify 
+            # troubleshooting, and without changing the exception type. 
+            exc.reason += ' in {} file at path: {}'.format(name, path) 
+            raise 
 
     def get_metadata_lines(self, name):
         return yield_lines(self.get_metadata(name))
@@ -1448,10 +1448,10 @@ class NullProvider:
     def run_script(self, script_name, namespace):
         script = 'scripts/' + script_name
         if not self.has_metadata(script):
-            raise ResolutionError(
-                "Script {script!r} not found in metadata at {self.egg_info!r}"
-                .format(**locals()),
-            )
+            raise ResolutionError( 
+                "Script {script!r} not found in metadata at {self.egg_info!r}" 
+                .format(**locals()), 
+            ) 
         script_text = self.get_metadata(script).replace('\r\n', '\n')
         script_text = script_text.replace('\r', '\n')
         script_filename = self._fn(self.egg_info, script)
@@ -1484,86 +1484,86 @@ class NullProvider:
         )
 
     def _fn(self, base, resource_name):
-        self._validate_resource_path(resource_name)
+        self._validate_resource_path(resource_name) 
         if resource_name:
             return os.path.join(base, *resource_name.split('/'))
         return base
 
-    @staticmethod
-    def _validate_resource_path(path):
-        """
-        Validate the resource paths according to the docs.
-        https://setuptools.readthedocs.io/en/latest/pkg_resources.html#basic-resource-access
-
-        >>> warned = getfixture('recwarn')
-        >>> warnings.simplefilter('always')
-        >>> vrp = NullProvider._validate_resource_path
-        >>> vrp('foo/bar.txt')
-        >>> bool(warned)
-        False
-        >>> vrp('../foo/bar.txt')
-        >>> bool(warned)
-        True
-        >>> warned.clear()
-        >>> vrp('/foo/bar.txt')
-        >>> bool(warned)
-        True
-        >>> vrp('foo/../../bar.txt')
-        >>> bool(warned)
-        True
-        >>> warned.clear()
-        >>> vrp('foo/f../bar.txt')
-        >>> bool(warned)
-        False
-
-        Windows path separators are straight-up disallowed.
-        >>> vrp(r'\\foo/bar.txt')
-        Traceback (most recent call last):
-        ...
-        ValueError: Use of .. or absolute path in a resource path \
-is not allowed.
-
-        >>> vrp(r'C:\\foo/bar.txt')
-        Traceback (most recent call last):
-        ...
-        ValueError: Use of .. or absolute path in a resource path \
-is not allowed.
-
-        Blank values are allowed
-
-        >>> vrp('')
-        >>> bool(warned)
-        False
-
-        Non-string values are not.
-
-        >>> vrp(None)
-        Traceback (most recent call last):
-        ...
-        AttributeError: ...
-        """
-        invalid = (
-            os.path.pardir in path.split(posixpath.sep) or
-            posixpath.isabs(path) or
-            ntpath.isabs(path)
-        )
-        if not invalid:
-            return
-
-        msg = "Use of .. or absolute path in a resource path is not allowed."
-
-        # Aggressively disallow Windows absolute paths
-        if ntpath.isabs(path) and not posixpath.isabs(path):
-            raise ValueError(msg)
-
-        # for compatibility, warn; in future
-        # raise ValueError(msg)
-        warnings.warn(
-            msg[:-1] + " and will raise exceptions in a future release.",
-            DeprecationWarning,
-            stacklevel=4,
-        )
-
+    @staticmethod 
+    def _validate_resource_path(path): 
+        """ 
+        Validate the resource paths according to the docs. 
+        https://setuptools.readthedocs.io/en/latest/pkg_resources.html#basic-resource-access 
+ 
+        >>> warned = getfixture('recwarn') 
+        >>> warnings.simplefilter('always') 
+        >>> vrp = NullProvider._validate_resource_path 
+        >>> vrp('foo/bar.txt') 
+        >>> bool(warned) 
+        False 
+        >>> vrp('../foo/bar.txt') 
+        >>> bool(warned) 
+        True 
+        >>> warned.clear() 
+        >>> vrp('/foo/bar.txt') 
+        >>> bool(warned) 
+        True 
+        >>> vrp('foo/../../bar.txt') 
+        >>> bool(warned) 
+        True 
+        >>> warned.clear() 
+        >>> vrp('foo/f../bar.txt') 
+        >>> bool(warned) 
+        False 
+ 
+        Windows path separators are straight-up disallowed. 
+        >>> vrp(r'\\foo/bar.txt') 
+        Traceback (most recent call last): 
+        ... 
+        ValueError: Use of .. or absolute path in a resource path \ 
+is not allowed. 
+ 
+        >>> vrp(r'C:\\foo/bar.txt') 
+        Traceback (most recent call last): 
+        ... 
+        ValueError: Use of .. or absolute path in a resource path \ 
+is not allowed. 
+ 
+        Blank values are allowed 
+ 
+        >>> vrp('') 
+        >>> bool(warned) 
+        False 
+ 
+        Non-string values are not. 
+ 
+        >>> vrp(None) 
+        Traceback (most recent call last): 
+        ... 
+        AttributeError: ... 
+        """ 
+        invalid = ( 
+            os.path.pardir in path.split(posixpath.sep) or 
+            posixpath.isabs(path) or 
+            ntpath.isabs(path) 
+        ) 
+        if not invalid: 
+            return 
+ 
+        msg = "Use of .. or absolute path in a resource path is not allowed." 
+ 
+        # Aggressively disallow Windows absolute paths 
+        if ntpath.isabs(path) and not posixpath.isabs(path): 
+            raise ValueError(msg) 
+ 
+        # for compatibility, warn; in future 
+        # raise ValueError(msg) 
+        warnings.warn( 
+            msg[:-1] + " and will raise exceptions in a future release.", 
+            DeprecationWarning, 
+            stacklevel=4, 
+        ) 
+ 
     def _get(self, path):
         if hasattr(self.loader, 'get_data'):
             return self.loader.get_data(path)
@@ -1588,7 +1588,7 @@ class EggProvider(NullProvider):
         path = self.module_path
         old = None
         while path != old:
-            if _is_egg_path(path):
+            if _is_egg_path(path): 
                 self.egg_name = os.path.basename(path)
                 self.egg_info = os.path.join(path, 'EGG-INFO')
                 self.egg_root = path
@@ -1618,10 +1618,10 @@ class DefaultProvider(EggProvider):
 
     @classmethod
     def _register(cls):
-        loader_names = 'SourceFileLoader', 'SourcelessFileLoader',
-        for name in loader_names:
-            loader_cls = getattr(importlib_machinery, name, type(None))
-            register_loader_type(loader_cls, cls)
+        loader_names = 'SourceFileLoader', 'SourcelessFileLoader', 
+        for name in loader_names: 
+            loader_cls = getattr(importlib_machinery, name, type(None)) 
+            register_loader_type(loader_cls, cls) 
 
 
 DefaultProvider._register()
@@ -1632,14 +1632,14 @@ class EmptyProvider(NullProvider):
 
     module_path = None
 
-    _isdir = _has = lambda self, path: False
-
-    def _get(self, path):
-        return ''
-
-    def _listdir(self, path):
-        return []
-
+    _isdir = _has = lambda self, path: False 
+ 
+    def _get(self, path): 
+        return '' 
+ 
+    def _listdir(self, path): 
+        return [] 
+ 
     def __init__(self):
         pass
 
@@ -1661,7 +1661,7 @@ class ZipManifests(dict):
         Use a platform-specific path separator (os.sep) for the path keys
         for compatibility with pypy on Windows.
         """
-        with zipfile.ZipFile(path) as zfile:
+        with zipfile.ZipFile(path) as zfile: 
             items = (
                 (
                     name.replace('/', os.sep),
@@ -1707,9 +1707,9 @@ class ZipProvider(EggProvider):
     def _zipinfo_name(self, fspath):
         # Convert a virtual filename (full path to file) into a zipfile subpath
         # usable with the zipimport directory cache for our target archive
-        fspath = fspath.rstrip(os.sep)
-        if fspath == self.loader.archive:
-            return ''
+        fspath = fspath.rstrip(os.sep) 
+        if fspath == self.loader.archive: 
+            return '' 
         if fspath.startswith(self.zip_pre):
             return fspath[len(self.zip_pre):]
         raise AssertionError(
@@ -1776,10 +1776,10 @@ class ZipProvider(EggProvider):
             if self._is_current(real_path, zip_path):
                 return real_path
 
-            outf, tmpnam = _mkstemp(
-                ".$extract",
-                dir=os.path.dirname(real_path),
-            )
+            outf, tmpnam = _mkstemp( 
+                ".$extract", 
+                dir=os.path.dirname(real_path), 
+            ) 
             os.write(outf, self.loader.get_data(zip_path))
             os.close(outf)
             utime(tmpnam, (timestamp, timestamp))
@@ -1884,9 +1884,9 @@ class FileMetadata(EmptyProvider):
     def __init__(self, path):
         self.path = path
 
-    def _get_metadata_path(self, name):
-        return self.path
-
+    def _get_metadata_path(self, name): 
+        return self.path 
+ 
     def has_metadata(self, name):
         return name == 'PKG-INFO' and os.path.isfile(self.path)
 
@@ -1900,7 +1900,7 @@ class FileMetadata(EmptyProvider):
         return metadata
 
     def _warn_on_replacement(self, metadata):
-        # Python 2.7 compat for: replacement_char = '�'
+        # Python 2.7 compat for: replacement_char = '�' 
         replacement_char = b'\xef\xbf\xbd'.decode('utf-8')
         if replacement_char in metadata:
             tmpl = "{self.path} could not be properly decoded in UTF-8"
@@ -1985,11 +1985,11 @@ def find_eggs_in_zip(importer, path_item, only=False):
     if only:
         # don't yield nested distros
         return
-    for subitem in metadata.resource_listdir(''):
-        if _is_egg_path(subitem):
+    for subitem in metadata.resource_listdir(''): 
+        if _is_egg_path(subitem): 
             subpath = os.path.join(path_item, subitem)
-            dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
-            for dist in dists:
+            dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath) 
+            for dist in dists: 
                 yield dist
         elif subitem.lower().endswith('.dist-info'):
             subpath = os.path.join(path_item, subitem)
@@ -2038,129 +2038,129 @@ def find_on_path(importer, path_item, only=False):
     """Yield distributions accessible on a sys.path directory"""
     path_item = _normalize_cached(path_item)
 
-    if _is_unpacked_egg(path_item):
-        yield Distribution.from_filename(
-            path_item, metadata=PathMetadata(
-                path_item, os.path.join(path_item, 'EGG-INFO')
+    if _is_unpacked_egg(path_item): 
+        yield Distribution.from_filename( 
+            path_item, metadata=PathMetadata( 
+                path_item, os.path.join(path_item, 'EGG-INFO') 
             )
-        )
-        return
-
-    entries = safe_listdir(path_item)
-
-    # for performance, before sorting by version,
-    # screen entries for only those that will yield
-    # distributions
-    filtered = (
-        entry
-        for entry in entries
-        if dist_factory(path_item, entry, only)
-    )
-
-    # scan for .egg and .egg-info in directory
-    path_item_entries = _by_version_descending(filtered)
-    for entry in path_item_entries:
-        fullpath = os.path.join(path_item, entry)
-        factory = dist_factory(path_item, entry, only)
-        for dist in factory(fullpath):
-            yield dist
-
-
-def dist_factory(path_item, entry, only):
-    """
-    Return a dist_factory for a path_item and entry
-    """
-    lower = entry.lower()
-    is_meta = any(map(lower.endswith, ('.egg-info', '.dist-info')))
-    return (
-        distributions_from_metadata
-        if is_meta else
-        find_distributions
-        if not only and _is_egg_path(entry) else
-        resolve_egg_link
-        if not only and lower.endswith('.egg-link') else
-        NoDists()
-    )
-
-
-class NoDists:
-    """
-    >>> bool(NoDists())
-    False
-
-    >>> list(NoDists()('anything'))
-    []
-    """
-    def __bool__(self):
-        return False
-    if six.PY2:
-        __nonzero__ = __bool__
-
-    def __call__(self, fullpath):
-        return iter(())
-
-
-def safe_listdir(path):
-    """
-    Attempt to list contents of path, but suppress some exceptions.
-    """
-    try:
-        return os.listdir(path)
-    except (PermissionError, NotADirectoryError):
-        pass
-    except OSError as e:
-        # Ignore the directory if does not exist, not a directory or
-        # permission denied
-        ignorable = (
-            e.errno in (errno.ENOTDIR, errno.EACCES, errno.ENOENT)
-            # Python 2 on Windows needs to be handled this way :(
-            or getattr(e, "winerror", None) == 267
-        )
-        if not ignorable:
-            raise
-    return ()
-
-
-def distributions_from_metadata(path):
-    root = os.path.dirname(path)
-    if os.path.isdir(path):
-        if len(os.listdir(path)) == 0:
-            # empty metadata dir; skip
-            return
-        metadata = PathMetadata(root, path)
-    else:
-        metadata = FileMetadata(path)
-    entry = os.path.basename(path)
-    yield Distribution.from_location(
-        root, entry, metadata, precedence=DEVELOP_DIST,
-    )
-
-
-def non_empty_lines(path):
-    """
-    Yield non-empty lines from file at path
-    """
-    with open(path) as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                yield line
-
-
-def resolve_egg_link(path):
-    """
-    Given a path to an .egg-link, resolve distributions
-    present in the referenced path.
-    """
-    referenced_paths = non_empty_lines(path)
-    resolved_paths = (
-        os.path.join(os.path.dirname(path), ref)
-        for ref in referenced_paths
-    )
-    dist_groups = map(find_distributions, resolved_paths)
-    return next(dist_groups, ())
-
-
+        ) 
+        return 
+
+    entries = safe_listdir(path_item) 
+
+    # for performance, before sorting by version, 
+    # screen entries for only those that will yield 
+    # distributions 
+    filtered = ( 
+        entry 
+        for entry in entries 
+        if dist_factory(path_item, entry, only) 
+    ) 
+ 
+    # scan for .egg and .egg-info in directory 
+    path_item_entries = _by_version_descending(filtered) 
+    for entry in path_item_entries: 
+        fullpath = os.path.join(path_item, entry) 
+        factory = dist_factory(path_item, entry, only) 
+        for dist in factory(fullpath): 
+            yield dist 
+ 
+ 
+def dist_factory(path_item, entry, only): 
+    """ 
+    Return a dist_factory for a path_item and entry 
+    """ 
+    lower = entry.lower() 
+    is_meta = any(map(lower.endswith, ('.egg-info', '.dist-info'))) 
+    return ( 
+        distributions_from_metadata 
+        if is_meta else 
+        find_distributions 
+        if not only and _is_egg_path(entry) else 
+        resolve_egg_link 
+        if not only and lower.endswith('.egg-link') else 
+        NoDists() 
+    ) 
+ 
+ 
+class NoDists: 
+    """ 
+    >>> bool(NoDists()) 
+    False 
+ 
+    >>> list(NoDists()('anything')) 
+    [] 
+    """ 
+    def __bool__(self): 
+        return False 
+    if six.PY2: 
+        __nonzero__ = __bool__ 
+ 
+    def __call__(self, fullpath): 
+        return iter(()) 
+ 
+ 
+def safe_listdir(path): 
+    """ 
+    Attempt to list contents of path, but suppress some exceptions. 
+    """ 
+    try: 
+        return os.listdir(path) 
+    except (PermissionError, NotADirectoryError): 
+        pass 
+    except OSError as e: 
+        # Ignore the directory if does not exist, not a directory or 
+        # permission denied 
+        ignorable = ( 
+            e.errno in (errno.ENOTDIR, errno.EACCES, errno.ENOENT) 
+            # Python 2 on Windows needs to be handled this way :( 
+            or getattr(e, "winerror", None) == 267 
+        ) 
+        if not ignorable: 
+            raise 
+    return () 
+ 
+ 
+def distributions_from_metadata(path): 
+    root = os.path.dirname(path) 
+    if os.path.isdir(path): 
+        if len(os.listdir(path)) == 0: 
+            # empty metadata dir; skip 
+            return 
+        metadata = PathMetadata(root, path) 
+    else: 
+        metadata = FileMetadata(path) 
+    entry = os.path.basename(path) 
+    yield Distribution.from_location( 
+        root, entry, metadata, precedence=DEVELOP_DIST, 
+    ) 
+ 
+ 
+def non_empty_lines(path): 
+    """ 
+    Yield non-empty lines from file at path 
+    """ 
+    with open(path) as f: 
+        for line in f: 
+            line = line.strip() 
+            if line: 
+                yield line 
+ 
+ 
+def resolve_egg_link(path): 
+    """ 
+    Given a path to an .egg-link, resolve distributions 
+    present in the referenced path. 
+    """ 
+    referenced_paths = non_empty_lines(path) 
+    resolved_paths = ( 
+        os.path.join(os.path.dirname(path), ref) 
+        for ref in referenced_paths 
+    ) 
+    dist_groups = map(find_distributions, resolved_paths) 
+    return next(dist_groups, ()) 
+ 
+ 
 register_finder(pkgutil.ImpImporter, find_on_path)
 
 if hasattr(importlib_machinery, 'FileFinder'):
@@ -2194,12 +2194,12 @@ def _handle_ns(packageName, path_item):
     importer = get_importer(path_item)
     if importer is None:
         return None
-
-    # capture warnings due to #1111
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        loader = importer.find_module(packageName)
-
+ 
+    # capture warnings due to #1111 
+    with warnings.catch_warnings(): 
+        warnings.simplefilter("ignore") 
+        loader = importer.find_module(packageName) 
+ 
     if loader is None:
         return None
     module = sys.modules.get(packageName)
@@ -2244,13 +2244,13 @@ def _rebuild_mod_path(orig_path, package_name, module):
         parts = path_parts[:-module_parts]
         return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
 
-    new_path = sorted(orig_path, key=position_in_sys_path)
-    new_path = [_normalize_cached(p) for p in new_path]
+    new_path = sorted(orig_path, key=position_in_sys_path) 
+    new_path = [_normalize_cached(p) for p in new_path] 
 
-    if isinstance(module.__path__, list):
-        module.__path__[:] = new_path
-    else:
-        module.__path__ = new_path
+    if isinstance(module.__path__, list): 
+        module.__path__[:] = new_path 
+    else: 
+        module.__path__ = new_path 
 
 
 def declare_namespace(packageName):
@@ -2261,10 +2261,10 @@ def declare_namespace(packageName):
         if packageName in _namespace_packages:
             return
 
-        path = sys.path
-        parent, _, _ = packageName.rpartition('.')
-
-        if parent:
+        path = sys.path 
+        parent, _, _ = packageName.rpartition('.') 
+ 
+        if parent: 
             declare_namespace(parent)
             if parent not in _namespace_packages:
                 __import__(parent)
@@ -2275,7 +2275,7 @@ def declare_namespace(packageName):
 
         # Track what packages are namespaces, so when new path items are added,
         # they can be updated
-        _namespace_packages.setdefault(parent or None, []).append(packageName)
+        _namespace_packages.setdefault(parent or None, []).append(packageName) 
         _namespace_packages.setdefault(packageName, [])
 
         for path_item in path:
@@ -2328,20 +2328,20 @@ register_namespace_handler(object, null_ns_handler)
 
 def normalize_path(filename):
     """Normalize a file/dir name for comparison purposes"""
-    return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename))))
-
-
-def _cygwin_patch(filename):  # pragma: nocover
-    """
-    Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
-    symlink components. Using
-    os.path.abspath() works around this limitation. A fix in os.getcwd()
-    would probably better, in Cygwin even more so, except
-    that this seems to be by design...
-    """
-    return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
-
-
+    return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename)))) 
+
+
+def _cygwin_patch(filename):  # pragma: nocover 
+    """ 
+    Contrary to POSIX 2008, on Cygwin, getcwd (3) contains 
+    symlink components. Using 
+    os.path.abspath() works around this limitation. A fix in os.getcwd() 
+    would probably better, in Cygwin even more so, except 
+    that this seems to be by design... 
+    """ 
+    return os.path.abspath(filename) if sys.platform == 'cygwin' else filename 
+ 
+ 
 def _normalize_cached(filename, _cache={}):
     try:
         return _cache[filename]
@@ -2350,20 +2350,20 @@ def _normalize_cached(filename, _cache={}):
         return result
 
 
-def _is_egg_path(path):
-    """
-    Determine if given path appears to be an egg.
-    """
-    return path.lower().endswith('.egg')
-
-
+def _is_egg_path(path): 
+    """ 
+    Determine if given path appears to be an egg. 
+    """ 
+    return path.lower().endswith('.egg') 
+ 
+ 
 def _is_unpacked_egg(path):
     """
     Determine if given path appears to be an unpacked egg.
     """
     return (
-        _is_egg_path(path) and
-        os.path.isfile(os.path.join(path, 'EGG-INFO', 'PKG-INFO'))
+        _is_egg_path(path) and 
+        os.path.isfile(os.path.join(path, 'EGG-INFO', 'PKG-INFO')) 
     )
 
 
@@ -2404,7 +2404,7 @@ EGG_NAME = re.compile(
 ).match
 
 
-class EntryPoint:
+class EntryPoint: 
     """Object representing an advertised importable object"""
 
     def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
@@ -2413,7 +2413,7 @@ class EntryPoint:
         self.name = name
         self.module_name = module_name
         self.attrs = tuple(attrs)
-        self.extras = tuple(extras)
+        self.extras = tuple(extras) 
         self.dist = dist
 
     def __str__(self):
@@ -2435,7 +2435,7 @@ class EntryPoint:
             warnings.warn(
                 "Parameters to load are deprecated.  Call .resolve and "
                 ".require separately.",
-                PkgResourcesDeprecationWarning,
+                PkgResourcesDeprecationWarning, 
                 stacklevel=2,
             )
         if require:
@@ -2550,20 +2550,20 @@ def _version_from_file(lines):
     Given an iterable of lines from a Metadata file, return
     the value of the Version field, if present, or None otherwise.
     """
-    def is_version_line(line):
-        return line.lower().startswith('version:')
+    def is_version_line(line): 
+        return line.lower().startswith('version:') 
     version_lines = filter(is_version_line, lines)
     line = next(iter(version_lines), '')
     _, _, value = line.partition(':')
     return safe_version(value.strip()) or None
 
 
-class Distribution:
+class Distribution: 
     """Wrap an actual or potential sys.path entry w/metadata"""
     PKG_INFO = 'PKG-INFO'
 
-    def __init__(
-            self, location=None, metadata=None, project_name=None,
+    def __init__( 
+            self, location=None, metadata=None, project_name=None, 
             version=None, py_version=PY_MAJOR, platform=None,
             precedence=EGG_DIST):
         self.project_name = safe_name(project_name or 'Unknown')
@@ -2680,57 +2680,57 @@ class Distribution:
         try:
             return self._version
         except AttributeError:
-            version = self._get_version()
+            version = self._get_version() 
             if version is None:
-                path = self._get_metadata_path_for_display(self.PKG_INFO)
-                msg = (
-                    "Missing 'Version:' header and/or {} file at path: {}"
-                ).format(self.PKG_INFO, path)
-                raise ValueError(msg, self)
-
+                path = self._get_metadata_path_for_display(self.PKG_INFO) 
+                msg = ( 
+                    "Missing 'Version:' header and/or {} file at path: {}" 
+                ).format(self.PKG_INFO, path) 
+                raise ValueError(msg, self) 
+ 
             return version
 
     @property
     def _dep_map(self):
-        """
-        A map of extra to its list of (direct) requirements
-        for this distribution, including the null extra.
-        """
+        """ 
+        A map of extra to its list of (direct) requirements 
+        for this distribution, including the null extra. 
+        """ 
         try:
             return self.__dep_map
         except AttributeError:
-            self.__dep_map = self._filter_extras(self._build_dep_map())
-        return self.__dep_map
-
-    @staticmethod
-    def _filter_extras(dm):
-        """
-        Given a mapping of extras to dependencies, strip off
-        environment markers and filter out any dependencies
-        not matching the markers.
-        """
-        for extra in list(filter(None, dm)):
-            new_extra = extra
-            reqs = dm.pop(extra)
-            new_extra, _, marker = extra.partition(':')
-            fails_marker = marker and (
-                invalid_marker(marker)
-                or not evaluate_marker(marker)
-            )
-            if fails_marker:
-                reqs = []
-            new_extra = safe_extra(new_extra) or None
-
-            dm.setdefault(new_extra, []).extend(reqs)
-        return dm
-
-    def _build_dep_map(self):
-        dm = {}
-        for name in 'requires.txt', 'depends.txt':
-            for extra, reqs in split_sections(self._get_metadata(name)):
-                dm.setdefault(extra, []).extend(parse_requirements(reqs))
-        return dm
-
+            self.__dep_map = self._filter_extras(self._build_dep_map()) 
+        return self.__dep_map 
+
+    @staticmethod 
+    def _filter_extras(dm): 
+        """ 
+        Given a mapping of extras to dependencies, strip off 
+        environment markers and filter out any dependencies 
+        not matching the markers. 
+        """ 
+        for extra in list(filter(None, dm)): 
+            new_extra = extra 
+            reqs = dm.pop(extra) 
+            new_extra, _, marker = extra.partition(':') 
+            fails_marker = marker and ( 
+                invalid_marker(marker) 
+                or not evaluate_marker(marker) 
+            ) 
+            if fails_marker: 
+                reqs = [] 
+            new_extra = safe_extra(new_extra) or None 
+ 
+            dm.setdefault(new_extra, []).extend(reqs) 
+        return dm 
+ 
+    def _build_dep_map(self): 
+        dm = {} 
+        for name in 'requires.txt', 'depends.txt': 
+            for extra, reqs in split_sections(self._get_metadata(name)): 
+                dm.setdefault(extra, []).extend(parse_requirements(reqs)) 
+        return dm 
+ 
     def requires(self, extras=()):
         """List of Requirements needed for this distro if `extras` are used"""
         dm = self._dep_map
@@ -2745,34 +2745,34 @@ class Distribution:
                 )
         return deps
 
-    def _get_metadata_path_for_display(self, name):
-        """
-        Return the path to the given metadata file, if available.
-        """
-        try:
-            # We need to access _get_metadata_path() on the provider object
-            # directly rather than through this class's __getattr__()
-            # since _get_metadata_path() is marked private.
-            path = self._provider._get_metadata_path(name)
-
-        # Handle exceptions e.g. in case the distribution's metadata
-        # provider doesn't support _get_metadata_path().
-        except Exception:
-            return '[could not detect]'
-
-        return path
-
+    def _get_metadata_path_for_display(self, name): 
+        """ 
+        Return the path to the given metadata file, if available. 
+        """ 
+        try: 
+            # We need to access _get_metadata_path() on the provider object 
+            # directly rather than through this class's __getattr__() 
+            # since _get_metadata_path() is marked private. 
+            path = self._provider._get_metadata_path(name) 
+ 
+        # Handle exceptions e.g. in case the distribution's metadata 
+        # provider doesn't support _get_metadata_path(). 
+        except Exception: 
+            return '[could not detect]' 
+ 
+        return path 
+ 
     def _get_metadata(self, name):
         if self.has_metadata(name):
             for line in self.get_metadata_lines(name):
                 yield line
 
-    def _get_version(self):
-        lines = self._get_metadata(self.PKG_INFO)
-        version = _version_from_file(lines)
-
-        return version
-
+    def _get_version(self): 
+        lines = self._get_metadata(self.PKG_INFO) 
+        version = _version_from_file(lines) 
+ 
+        return version 
+ 
     def activate(self, path=None, replace=False):
         """Ensure distribution is importable on `path` (default=sys.path)"""
         if path is None:
@@ -2815,19 +2815,19 @@ class Distribution:
             raise AttributeError(attr)
         return getattr(self._provider, attr)
 
-    def __dir__(self):
-        return list(
-            set(super(Distribution, self).__dir__())
-            | set(
-                attr for attr in self._provider.__dir__()
-                if not attr.startswith('_')
-            )
-        )
-
-    if not hasattr(object, '__dir__'):
-        # python 2.7 not supported
-        del __dir__
-
+    def __dir__(self): 
+        return list( 
+            set(super(Distribution, self).__dir__()) 
+            | set( 
+                attr for attr in self._provider.__dir__() 
+                if not attr.startswith('_') 
+            ) 
+        ) 
+ 
+    if not hasattr(object, '__dir__'): 
+        # python 2.7 not supported 
+        del __dir__ 
+ 
     @classmethod
     def from_filename(cls, filename, metadata=None, **kw):
         return cls.from_location(
@@ -2900,8 +2900,8 @@ class Distribution:
                 if replace:
                     break
                 else:
-                    # don't modify path (even removing duplicates) if
-                    # found and not replace
+                    # don't modify path (even removing duplicates) if 
+                    # found and not replace 
                     return
             elif item == bdir and self.precedence == EGG_DIST:
                 # if it's an .egg, give it precedence over its directory
@@ -2991,17 +2991,17 @@ class EggInfoDistribution(Distribution):
         take an extra step and try to get the version number from
         the metadata file itself instead of the filename.
         """
-        md_version = self._get_version()
+        md_version = self._get_version() 
         if md_version:
             self._version = md_version
         return self
 
 
 class DistInfoDistribution(Distribution):
-    """
-    Wrap an actual or potential sys.path entry
-    w/metadata, .dist-info style.
-    """
+    """ 
+    Wrap an actual or potential sys.path entry 
+    w/metadata, .dist-info style. 
+    """ 
     PKG_INFO = 'METADATA'
     EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
 
@@ -3051,7 +3051,7 @@ _distributionImpl = {
     '.egg': Distribution,
     '.egg-info': EggInfoDistribution,
     '.dist-info': DistInfoDistribution,
-}
+} 
 
 
 def issue_warning(*args, **kw):
@@ -3087,10 +3087,10 @@ def parse_requirements(strs):
         # If there is a line continuation, drop it, and append the next line.
         if line.endswith('\\'):
             line = line[:-2].strip()
-            try:
-                line += next(lines)
-            except StopIteration:
-                return
+            try: 
+                line += next(lines) 
+            except StopIteration: 
+                return 
         yield Requirement(line)
 
 
@@ -3109,7 +3109,7 @@ class Requirement(packaging.requirements.Requirement):
         self.extras = tuple(map(safe_extra, self.extras))
         self.hashCmp = (
             self.key,
-            self.url,
+            self.url, 
             self.specifier,
             frozenset(self.extras),
             str(self.marker) if self.marker else None,
@@ -3140,8 +3140,8 @@ class Requirement(packaging.requirements.Requirement):
     def __hash__(self):
         return self.__hash
 
-    def __repr__(self):
-        return "Requirement.parse(%r)" % str(self)
+    def __repr__(self): 
+        return "Requirement.parse(%r)" % str(self) 
 
     @staticmethod
     def parse(s):
@@ -3149,20 +3149,20 @@ class Requirement(packaging.requirements.Requirement):
         return req
 
 
-def _always_object(classes):
-    """
-    Ensure object appears in the mro even
-    for old-style classes.
-    """
-    if object not in classes:
-        return classes + (object,)
-    return classes
+def _always_object(classes): 
+    """ 
+    Ensure object appears in the mro even 
+    for old-style classes. 
+    """ 
+    if object not in classes: 
+        return classes + (object,) 
+    return classes 
 
 
 def _find_adapter(registry, ob):
     """Return an adapter factory for `ob` from `registry`"""
-    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
-    for t in types:
+    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob)))) 
+    for t in types: 
         if t in registry:
             return registry[t]
 
@@ -3170,7 +3170,7 @@ def _find_adapter(registry, ob):
 def ensure_directory(path):
     """Ensure that the parent directory of `path` exists"""
     dirname = os.path.dirname(path)
-    py31compat.makedirs(dirname, exist_ok=True)
+    py31compat.makedirs(dirname, exist_ok=True) 
 
 
 def _bypass_ensure_directory(path):
@@ -3180,10 +3180,10 @@ def _bypass_ensure_directory(path):
     dirname, filename = split(path)
     if dirname and filename and not isdir(dirname):
         _bypass_ensure_directory(dirname)
-        try:
-            mkdir(dirname, 0o755)
-        except FileExistsError:
-            pass
+        try: 
+            mkdir(dirname, 0o755) 
+        except FileExistsError: 
+            pass 
 
 
 def split_sections(s):
@@ -3224,7 +3224,7 @@ def _mkstemp(*args, **kw):
 
 
 # Yandex resource support
-from __res import Y_PYTHON_SOURCE_ROOT, ResourceImporter, executable
+from __res import Y_PYTHON_SOURCE_ROOT, ResourceImporter, executable 
 from library.python import resource
 
 
@@ -3232,35 +3232,35 @@ class ResProvider(EmptyProvider):
     _resource_fs = {}
 
     def __init__(self, prefix):
-        if hasattr(prefix, '__file__'):
-            key = prefix.__file__.rsplit('/', 1)[0]
-            self.module_path = 'resfs/file/{}/'.format(key)
-            # Метаданные лежат на уровень выше самого пакета
-            key = key.rsplit('/', 1)[0]
-            self.egg_info = 'resfs/file/{}/.dist-info/'.format(key)
-        else:
-            # Сюда попадаем только из ResDistribution, который работает
-            # только метаданными, поэтому self.module_path не используется
-            self.egg_info = prefix
-
-    @staticmethod
-    def from_module(module):
-        if Y_PYTHON_SOURCE_ROOT:
-            return DefaultProvider(module)
-        else:
-            return ResProvider(module)
-
-    def _fn(self, base, resource_name):
-        return base + resource_name
-
+        if hasattr(prefix, '__file__'): 
+            key = prefix.__file__.rsplit('/', 1)[0] 
+            self.module_path = 'resfs/file/{}/'.format(key) 
+            # Метаданные лежат на уровень выше самого пакета 
+            key = key.rsplit('/', 1)[0] 
+            self.egg_info = 'resfs/file/{}/.dist-info/'.format(key) 
+        else: 
+            # Сюда попадаем только из ResDistribution, который работает 
+            # только метаданными, поэтому self.module_path не используется 
+            self.egg_info = prefix 
+
+    @staticmethod 
+    def from_module(module): 
+        if Y_PYTHON_SOURCE_ROOT: 
+            return DefaultProvider(module) 
+        else: 
+            return ResProvider(module) 
+ 
+    def _fn(self, base, resource_name): 
+        return base + resource_name 
+ 
     def _has(self, path):
-        return resource.find(path) is not None
+        return resource.find(path) is not None 
 
     def _get(self, path):
-        result = resource.find(path)
-        if result is None:
-            raise IOError(path)
-        return result
+        result = resource.find(path) 
+        if result is None: 
+            raise IOError(path) 
+        return result 
 
     @classmethod
     def _init_resource_fs(cls):
@@ -3298,7 +3298,7 @@ class ResDistribution(DistInfoDistribution):
             metadata=ResProvider(prefix),
             precedence=BINARY_DIST,
         )
-        self.project_name = self._parsed_pkg_info.get('Name', self.project_name)
+        self.project_name = self._parsed_pkg_info.get('Name', self.project_name) 
 
 
 def find_in_res(importer, path_item, only=False):
@@ -3308,7 +3308,7 @@ def find_in_res(importer, path_item, only=False):
 
 
 register_finder(ResourceImporter, find_in_res)
-register_loader_type(ResourceImporter, ResProvider.from_module)
+register_loader_type(ResourceImporter, ResProvider.from_module) 
 
 
 # Silence the PEP440Warning by default, so that end users don't get hit by it
@@ -3366,19 +3366,19 @@ def _initialize_master_working_set():
         dist.activate(replace=False)
         for dist in working_set
     )
-    add_activation_listener(
-        lambda dist: dist.activate(replace=True),
-        existing=False,
-    )
+    add_activation_listener( 
+        lambda dist: dist.activate(replace=True), 
+        existing=False, 
+    ) 
     working_set.entries = []
     # match order
     list(map(working_set.add_entry, sys.path))
     globals().update(locals())
-
-class PkgResourcesDeprecationWarning(Warning):
-    """
-    Base class for warning about deprecations in ``pkg_resources``
-
-    This class is not derived from ``DeprecationWarning``, and as such is
-    visible by default.
-    """
+ 
+class PkgResourcesDeprecationWarning(Warning): 
+    """ 
+    Base class for warning about deprecations in ``pkg_resources`` 
+ 
+    This class is not derived from ``DeprecationWarning``, and as such is 
+    visible by default. 
+    """ 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/appdirs.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/appdirs.py
index ae67001af8..dae7b2b79a 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/appdirs.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/appdirs.py
@@ -1,608 +1,608 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (c) 2005-2010 ActiveState Software Inc.
-# Copyright (c) 2013 Eddy Petrișor
-
-"""Utilities for determining application-specific dirs.
-
-See <http://github.com/ActiveState/appdirs> for details and usage.
-"""
-# Dev Notes:
-# - MSDN on where to store app data files:
-#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
-# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
-# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
-
-__version_info__ = (1, 4, 3)
-__version__ = '.'.join(map(str, __version_info__))
-
-
-import sys
-import os
-
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    unicode = str
-
-if sys.platform.startswith('java'):
-    import platform
-    os_name = platform.java_ver()[3][0]
-    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
-        system = 'win32'
-    elif os_name.startswith('Mac'): # "Mac OS X", etc.
-        system = 'darwin'
-    else: # "Linux", "SunOS", "FreeBSD", etc.
-        # Setting this to "linux2" is not ideal, but only Windows or Mac
-        # are actually checked for and the rest of the module expects
-        # *sys.platform* style strings.
-        system = 'linux2'
-else:
-    system = sys.platform
-
-
-
-def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user data directories are:
-        Mac OS X:               ~/Library/Application Support/<AppName>
-        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
-        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
-        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
-        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
-        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
-
-    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
-    That means, by default "~/.local/share/<AppName>".
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
-        path = os.path.normpath(_get_win_folder(const))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Application Support/')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
-    r"""Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of data dirs should be
-            returned. By default, the first item from XDG_DATA_DIRS is
-            returned, or '/usr/local/share/<AppName>',
-            if XDG_DATA_DIRS is not set
-
-    Typical site data directories are:
-        Mac OS X:   /Library/Application Support/<AppName>
-        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
-        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
-
-    For Unix, this is using the $XDG_DATA_DIRS[0] default.
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('/Library/Application Support')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        # XDG default for $XDG_DATA_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_DATA_DIRS',
-                         os.pathsep.join(['/usr/local/share', '/usr/share']))
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-        return path
-
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific config dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user config directories are:
-        Mac OS X:               same as user_data_dir
-        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
-        Win *:                  same as user_data_dir
-
-    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
-    That means, by default "~/.config/<AppName>".
-    """
-    if system in ["win32", "darwin"]:
-        path = user_data_dir(appname, appauthor, None, roaming)
-    else:
-        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
-    r"""Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of config dirs should be
-            returned. By default, the first item from XDG_CONFIG_DIRS is
-            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
-
-    Typical site config directories are:
-        Mac OS X:   same as site_data_dir
-        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
-                    $XDG_CONFIG_DIRS
-        Win *:      same as site_data_dir
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-
-    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system in ["win32", "darwin"]:
-        path = site_data_dir(appname, appauthor)
-        if appname and version:
-            path = os.path.join(path, version)
-    else:
-        # XDG default for $XDG_CONFIG_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-    return path
-
-
-def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific cache dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Cache" to the base app data dir for Windows. See
-            discussion below.
-
-    Typical user cache directories are:
-        Mac OS X:   ~/Library/Caches/<AppName>
-        Unix:       ~/.cache/<AppName> (XDG default)
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
-
-    On Windows the only suggestion in the MSDN docs is that local settings go in
-    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
-    app data dir (the default returned by `user_data_dir` above). Apps typically
-    put cache data somewhere *under* the given dir here. Some examples:
-        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
-        ...\Acme\SuperApp\Cache\1.0
-    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-            if opinion:
-                path = os.path.join(path, "Cache")
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Caches')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific state dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user state directories are:
-        Mac OS X:  same as user_data_dir
-        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
-        Win *:     same as user_data_dir
-
-    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
-    to extend the XDG spec and support $XDG_STATE_HOME.
-
-    That means, by default "~/.local/state/<AppName>".
-    """
-    if system in ["win32", "darwin"]:
-        path = user_data_dir(appname, appauthor, None, roaming)
-    else:
-        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific log dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Logs" to the base app data dir for Windows, and "log" to the
-            base cache dir for Unix. See discussion below.
-
-    Typical user log directories are:
-        Mac OS X:   ~/Library/Logs/<AppName>
-        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
-
-    On Windows the only suggestion in the MSDN docs is that local settings
-    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
-    examples of what some windows apps use for a logs dir.)
-
-    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
-    value for Windows and appends "log" to the user cache dir for Unix.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "darwin":
-        path = os.path.join(
-            os.path.expanduser('~/Library/Logs'),
-            appname)
-    elif system == "win32":
-        path = user_data_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "Logs")
-    else:
-        path = user_cache_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "log")
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-class AppDirs(object):
-    """Convenience wrapper for getting application dirs."""
-    def __init__(self, appname=None, appauthor=None, version=None,
-            roaming=False, multipath=False):
-        self.appname = appname
-        self.appauthor = appauthor
-        self.version = version
-        self.roaming = roaming
-        self.multipath = multipath
-
-    @property
-    def user_data_dir(self):
-        return user_data_dir(self.appname, self.appauthor,
-                             version=self.version, roaming=self.roaming)
-
-    @property
-    def site_data_dir(self):
-        return site_data_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_config_dir(self):
-        return user_config_dir(self.appname, self.appauthor,
-                               version=self.version, roaming=self.roaming)
-
-    @property
-    def site_config_dir(self):
-        return site_config_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_cache_dir(self):
-        return user_cache_dir(self.appname, self.appauthor,
-                              version=self.version)
-
-    @property
-    def user_state_dir(self):
-        return user_state_dir(self.appname, self.appauthor,
-                              version=self.version)
-
-    @property
-    def user_log_dir(self):
-        return user_log_dir(self.appname, self.appauthor,
-                            version=self.version)
-
-
-#---- internal support stuff
-
-def _get_win_folder_from_registry(csidl_name):
-    """This is a fallback technique at best. I'm not sure if using the
-    registry for this guarantees us the correct answer for all CSIDL_*
-    names.
-    """
-    if PY3:
-      import winreg as _winreg
-    else:
-      import _winreg
-
-    shell_folder_name = {
-        "CSIDL_APPDATA": "AppData",
-        "CSIDL_COMMON_APPDATA": "Common AppData",
-        "CSIDL_LOCAL_APPDATA": "Local AppData",
-    }[csidl_name]
-
-    key = _winreg.OpenKey(
-        _winreg.HKEY_CURRENT_USER,
-        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
-    )
-    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
-    return dir
-
-
-def _get_win_folder_with_pywin32(csidl_name):
-    from win32com.shell import shellcon, shell
-    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
-    # Try to make this a unicode path because SHGetFolderPath does
-    # not return unicode strings when there is unicode data in the
-    # path.
-    try:
-        dir = unicode(dir)
-
-        # Downgrade to short path name if have highbit chars. See
-        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-        has_high_char = False
-        for c in dir:
-            if ord(c) > 255:
-                has_high_char = True
-                break
-        if has_high_char:
-            try:
-                import win32api
-                dir = win32api.GetShortPathName(dir)
-            except ImportError:
-                pass
-    except UnicodeError:
-        pass
-    return dir
-
-
-def _get_win_folder_with_ctypes(csidl_name):
-    import ctypes
-
-    csidl_const = {
-        "CSIDL_APPDATA": 26,
-        "CSIDL_COMMON_APPDATA": 35,
-        "CSIDL_LOCAL_APPDATA": 28,
-    }[csidl_name]
-
-    buf = ctypes.create_unicode_buffer(1024)
-    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in buf:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf2 = ctypes.create_unicode_buffer(1024)
-        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
-            buf = buf2
-
-    return buf.value
-
-def _get_win_folder_with_jna(csidl_name):
-    import array
-    from com.sun import jna
-    from com.sun.jna.platform import win32
-
-    buf_size = win32.WinDef.MAX_PATH * 2
-    buf = array.zeros('c', buf_size)
-    shell = win32.Shell32.INSTANCE
-    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
-    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in dir:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf = array.zeros('c', buf_size)
-        kernel = win32.Kernel32.INSTANCE
-        if kernel.GetShortPathName(dir, buf, buf_size):
-            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    return dir
-
-if system == "win32":
-    try:
-        import win32com.shell
-        _get_win_folder = _get_win_folder_with_pywin32
-    except ImportError:
-        try:
-            from ctypes import windll
-            _get_win_folder = _get_win_folder_with_ctypes
-        except ImportError:
-            try:
-                import com.sun.jna
-                _get_win_folder = _get_win_folder_with_jna
-            except ImportError:
-                _get_win_folder = _get_win_folder_from_registry
-
-
-#---- self test code
-
-if __name__ == "__main__":
-    appname = "MyApp"
-    appauthor = "MyCompany"
-
-    props = ("user_data_dir",
-             "user_config_dir",
-             "user_cache_dir",
-             "user_state_dir",
-             "user_log_dir",
-             "site_data_dir",
-             "site_config_dir")
-
-    print("-- app dirs %s --" % __version__)
-
-    print("-- app dirs (with optional 'version')")
-    dirs = AppDirs(appname, appauthor, version="1.0")
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'version')")
-    dirs = AppDirs(appname, appauthor)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'appauthor')")
-    dirs = AppDirs(appname)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (with disabled 'appauthor')")
-    dirs = AppDirs(appname, appauthor=False)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
+#!/usr/bin/env python 
+# -*- coding: utf-8 -*- 
+# Copyright (c) 2005-2010 ActiveState Software Inc. 
+# Copyright (c) 2013 Eddy Petrișor 
+ 
+"""Utilities for determining application-specific dirs. 
+ 
+See <http://github.com/ActiveState/appdirs> for details and usage. 
+""" 
+# Dev Notes: 
+# - MSDN on where to store app data files: 
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120 
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html 
+# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html 
+ 
+__version_info__ = (1, 4, 3) 
+__version__ = '.'.join(map(str, __version_info__)) 
+ 
+ 
+import sys 
+import os 
+ 
+PY3 = sys.version_info[0] == 3 
+ 
+if PY3: 
+    unicode = str 
+ 
+if sys.platform.startswith('java'): 
+    import platform 
+    os_name = platform.java_ver()[3][0] 
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc. 
+        system = 'win32' 
+    elif os_name.startswith('Mac'): # "Mac OS X", etc. 
+        system = 'darwin' 
+    else: # "Linux", "SunOS", "FreeBSD", etc. 
+        # Setting this to "linux2" is not ideal, but only Windows or Mac 
+        # are actually checked for and the rest of the module expects 
+        # *sys.platform* style strings. 
+        system = 'linux2' 
+else: 
+    system = sys.platform 
+ 
+ 
+ 
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False): 
+    r"""Return full path to the user-specific data dir for this application. 
+ 
+        "appname" is the name of application. 
+            If None, just the system directory is returned. 
+        "appauthor" (only used on Windows) is the name of the 
+            appauthor or distributing body for this application. Typically 
+            it is the owning company name. This falls back to appname. You may 
+            pass False to disable it. 
+        "version" is an optional version path element to append to the 
+            path. You might want to use this if you want multiple versions 
+            of your app to be able to run independently. If used, this 
+            would typically be "<major>.<minor>". 
+            Only applied when appname is present. 
+        "roaming" (boolean, default False) can be set True to use the Windows 
+            roaming appdata directory. That means that for users on a Windows 
+            network setup for roaming profiles, this user data will be 
+            sync'd on login. See 
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx> 
+            for a discussion of issues. 
+ 
+    Typical user data directories are: 
+        Mac OS X:               ~/Library/Application Support/<AppName> 
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined 
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName> 
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName> 
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName> 
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName> 
+ 
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME. 
+    That means, by default "~/.local/share/<AppName>". 
+    """ 
+    if system == "win32": 
+        if appauthor is None: 
+            appauthor = appname 
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA" 
+        path = os.path.normpath(_get_win_folder(const)) 
+        if appname: 
+            if appauthor is not False: 
+                path = os.path.join(path, appauthor, appname) 
+            else: 
+                path = os.path.join(path, appname) 
+    elif system == 'darwin': 
+        path = os.path.expanduser('~/Library/Application Support/') 
+        if appname: 
+            path = os.path.join(path, appname) 
+    else: 
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share")) 
+        if appname: 
+            path = os.path.join(path, appname) 
+    if appname and version: 
+        path = os.path.join(path, version) 
+    return path 
+ 
+ 
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False): 
+    r"""Return full path to the user-shared data dir for this application. 
+ 
+        "appname" is the name of application. 
+            If None, just the system directory is returned. 
+        "appauthor" (only used on Windows) is the name of the 
+            appauthor or distributing body for this application. Typically 
+            it is the owning company name. This falls back to appname. You may 
+            pass False to disable it. 
+        "version" is an optional version path element to append to the 
+            path. You might want to use this if you want multiple versions 
+            of your app to be able to run independently. If used, this 
+            would typically be "<major>.<minor>". 
+            Only applied when appname is present. 
+        "multipath" is an optional parameter only applicable to *nix 
+            which indicates that the entire list of data dirs should be 
+            returned. By default, the first item from XDG_DATA_DIRS is 
+            returned, or '/usr/local/share/<AppName>', 
+            if XDG_DATA_DIRS is not set 
+ 
+    Typical site data directories are: 
+        Mac OS X:   /Library/Application Support/<AppName> 
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName> 
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName> 
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.) 
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7. 
+ 
+    For Unix, this is using the $XDG_DATA_DIRS[0] default. 
+ 
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why. 
+    """ 
+    if system == "win32": 
+        if appauthor is None: 
+            appauthor = appname 
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA")) 
+        if appname: 
+            if appauthor is not False: 
+                path = os.path.join(path, appauthor, appname) 
+            else: 
+                path = os.path.join(path, appname) 
+    elif system == 'darwin': 
+        path = os.path.expanduser('/Library/Application Support') 
+        if appname: 
+            path = os.path.join(path, appname) 
+    else: 
+        # XDG default for $XDG_DATA_DIRS 
+        # only first, if multipath is False 
+        path = os.getenv('XDG_DATA_DIRS', 
+                         os.pathsep.join(['/usr/local/share', '/usr/share'])) 
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)] 
+        if appname: 
+            if version: 
+                appname = os.path.join(appname, version) 
+            pathlist = [os.sep.join([x, appname]) for x in pathlist] 
+ 
+        if multipath: 
+            path = os.pathsep.join(pathlist) 
+        else: 
+            path = pathlist[0] 
+        return path 
+ 
+    if appname and version: 
+        path = os.path.join(path, version) 
+    return path 
+ 
+ 
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False): 
+    r"""Return full path to the user-specific config dir for this application. 
+ 
+        "appname" is the name of application. 
+            If None, just the system directory is returned. 
+        "appauthor" (only used on Windows) is the name of the 
+            appauthor or distributing body for this application. Typically 
+            it is the owning company name. This falls back to appname. You may 
+            pass False to disable it. 
+        "version" is an optional version path element to append to the 
+            path. You might want to use this if you want multiple versions 
+            of your app to be able to run independently. If used, this 
+            would typically be "<major>.<minor>". 
+            Only applied when appname is present. 
+        "roaming" (boolean, default False) can be set True to use the Windows 
+            roaming appdata directory. That means that for users on a Windows 
+            network setup for roaming profiles, this user data will be 
+            sync'd on login. See 
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx> 
+            for a discussion of issues. 
+ 
+    Typical user config directories are: 
+        Mac OS X:               same as user_data_dir 
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined 
+        Win *:                  same as user_data_dir 
+ 
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME. 
+    That means, by default "~/.config/<AppName>". 
+    """ 
+    if system in ["win32", "darwin"]: 
+        path = user_data_dir(appname, appauthor, None, roaming) 
+    else: 
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config")) 
+        if appname: 
+            path = os.path.join(path, appname) 
+    if appname and version: 
+        path = os.path.join(path, version) 
+    return path 
+ 
+ 
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False): 
+    r"""Return full path to the user-shared data dir for this application. 
+ 
+        "appname" is the name of application. 
+            If None, just the system directory is returned. 
+        "appauthor" (only used on Windows) is the name of the 
+            appauthor or distributing body for this application. Typically 
+            it is the owning company name. This falls back to appname. You may 
+            pass False to disable it. 
+        "version" is an optional version path element to append to the 
+            path. You might want to use this if you want multiple versions 
+            of your app to be able to run independently. If used, this 
+            would typically be "<major>.<minor>". 
+            Only applied when appname is present. 
+        "multipath" is an optional parameter only applicable to *nix 
+            which indicates that the entire list of config dirs should be 
+            returned. By default, the first item from XDG_CONFIG_DIRS is 
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set 
+ 
+    Typical site config directories are: 
+        Mac OS X:   same as site_data_dir 
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in 
+                    $XDG_CONFIG_DIRS 
+        Win *:      same as site_data_dir 
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.) 
+ 
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False 
+ 
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why. 
+    """ 
+    if system in ["win32", "darwin"]: 
+        path = site_data_dir(appname, appauthor) 
+        if appname and version: 
+            path = os.path.join(path, version) 
+    else: 
+        # XDG default for $XDG_CONFIG_DIRS 
+        # only first, if multipath is False 
+        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg') 
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)] 
+        if appname: 
+            if version: 
+                appname = os.path.join(appname, version) 
+            pathlist = [os.sep.join([x, appname]) for x in pathlist] 
+ 
+        if multipath: 
+            path = os.pathsep.join(pathlist) 
+        else: 
+            path = pathlist[0] 
+    return path 
+ 
+ 
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True): 
+    r"""Return full path to the user-specific cache dir for this application. 
+ 
+        "appname" is the name of application. 
+            If None, just the system directory is returned. 
+        "appauthor" (only used on Windows) is the name of the 
+            appauthor or distributing body for this application. Typically 
+            it is the owning company name. This falls back to appname. You may 
+            pass False to disable it. 
+        "version" is an optional version path element to append to the 
+            path. You might want to use this if you want multiple versions 
+            of your app to be able to run independently. If used, this 
+            would typically be "<major>.<minor>". 
+            Only applied when appname is present. 
+        "opinion" (boolean) can be False to disable the appending of 
+            "Cache" to the base app data dir for Windows. See 
+            discussion below. 
+ 
+    Typical user cache directories are: 
+        Mac OS X:   ~/Library/Caches/<AppName> 
+        Unix:       ~/.cache/<AppName> (XDG default) 
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache 
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache 
+ 
+    On Windows the only suggestion in the MSDN docs is that local settings go in 
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming 
+    app data dir (the default returned by `user_data_dir` above). Apps typically 
+    put cache data somewhere *under* the given dir here. Some examples: 
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache 
+        ...\Acme\SuperApp\Cache\1.0 
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value. 
+    This can be disabled with the `opinion=False` option. 
+    """ 
+    if system == "win32": 
+        if appauthor is None: 
+            appauthor = appname 
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA")) 
+        if appname: 
+            if appauthor is not False: 
+                path = os.path.join(path, appauthor, appname) 
+            else: 
+                path = os.path.join(path, appname) 
+            if opinion: 
+                path = os.path.join(path, "Cache") 
+    elif system == 'darwin': 
+        path = os.path.expanduser('~/Library/Caches') 
+        if appname: 
+            path = os.path.join(path, appname) 
+    else: 
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache')) 
+        if appname: 
+            path = os.path.join(path, appname) 
+    if appname and version: 
+        path = os.path.join(path, version) 
+    return path 
+ 
+ 
+def user_state_dir(appname=None, appauthor=None, version=None, roaming=False): 
+    r"""Return full path to the user-specific state dir for this application. 
+ 
+        "appname" is the name of application. 
+            If None, just the system directory is returned. 
+        "appauthor" (only used on Windows) is the name of the 
+            appauthor or distributing body for this application. Typically 
+            it is the owning company name. This falls back to appname. You may 
+            pass False to disable it. 
+        "version" is an optional version path element to append to the 
+            path. You might want to use this if you want multiple versions 
+            of your app to be able to run independently. If used, this 
+            would typically be "<major>.<minor>". 
+            Only applied when appname is present. 
+        "roaming" (boolean, default False) can be set True to use the Windows 
+            roaming appdata directory. That means that for users on a Windows 
+            network setup for roaming profiles, this user data will be 
+            sync'd on login. See 
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx> 
+            for a discussion of issues. 
+ 
+    Typical user state directories are: 
+        Mac OS X:  same as user_data_dir 
+        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined 
+        Win *:     same as user_data_dir 
+ 
+    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state> 
+    to extend the XDG spec and support $XDG_STATE_HOME. 
+ 
+    That means, by default "~/.local/state/<AppName>". 
+    """ 
+    if system in ["win32", "darwin"]: 
+        path = user_data_dir(appname, appauthor, None, roaming) 
+    else: 
+        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state")) 
+        if appname: 
+            path = os.path.join(path, appname) 
+    if appname and version: 
+        path = os.path.join(path, version) 
+    return path 
+ 
+ 
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True): 
+    r"""Return full path to the user-specific log dir for this application. 
+ 
+        "appname" is the name of application. 
+            If None, just the system directory is returned. 
+        "appauthor" (only used on Windows) is the name of the 
+            appauthor or distributing body for this application. Typically 
+            it is the owning company name. This falls back to appname. You may 
+            pass False to disable it. 
+        "version" is an optional version path element to append to the 
+            path. You might want to use this if you want multiple versions 
+            of your app to be able to run independently. If used, this 
+            would typically be "<major>.<minor>". 
+            Only applied when appname is present. 
+        "opinion" (boolean) can be False to disable the appending of 
+            "Logs" to the base app data dir for Windows, and "log" to the 
+            base cache dir for Unix. See discussion below. 
+ 
+    Typical user log directories are: 
+        Mac OS X:   ~/Library/Logs/<AppName> 
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined 
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs 
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs 
+ 
+    On Windows the only suggestion in the MSDN docs is that local settings 
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in 
+    examples of what some windows apps use for a logs dir.) 
+ 
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA` 
+    value for Windows and appends "log" to the user cache dir for Unix. 
+    This can be disabled with the `opinion=False` option. 
+    """ 
+    if system == "darwin": 
+        path = os.path.join( 
+            os.path.expanduser('~/Library/Logs'), 
+            appname) 
+    elif system == "win32": 
+        path = user_data_dir(appname, appauthor, version) 
+        version = False 
+        if opinion: 
+            path = os.path.join(path, "Logs") 
+    else: 
+        path = user_cache_dir(appname, appauthor, version) 
+        version = False 
+        if opinion: 
+            path = os.path.join(path, "log") 
+    if appname and version: 
+        path = os.path.join(path, version) 
+    return path 
+ 
+ 
+class AppDirs(object): 
+    """Convenience wrapper for getting application dirs.""" 
+    def __init__(self, appname=None, appauthor=None, version=None, 
+            roaming=False, multipath=False): 
+        self.appname = appname 
+        self.appauthor = appauthor 
+        self.version = version 
+        self.roaming = roaming 
+        self.multipath = multipath 
+ 
+    @property 
+    def user_data_dir(self): 
+        return user_data_dir(self.appname, self.appauthor, 
+                             version=self.version, roaming=self.roaming) 
+ 
+    @property 
+    def site_data_dir(self): 
+        return site_data_dir(self.appname, self.appauthor, 
+                             version=self.version, multipath=self.multipath) 
+ 
+    @property 
+    def user_config_dir(self): 
+        return user_config_dir(self.appname, self.appauthor, 
+                               version=self.version, roaming=self.roaming) 
+ 
+    @property 
+    def site_config_dir(self): 
+        return site_config_dir(self.appname, self.appauthor, 
+                             version=self.version, multipath=self.multipath) 
+ 
+    @property 
+    def user_cache_dir(self): 
+        return user_cache_dir(self.appname, self.appauthor, 
+                              version=self.version) 
+ 
+    @property 
+    def user_state_dir(self): 
+        return user_state_dir(self.appname, self.appauthor, 
+                              version=self.version) 
+ 
+    @property 
+    def user_log_dir(self): 
+        return user_log_dir(self.appname, self.appauthor, 
+                            version=self.version) 
+ 
+ 
+#---- internal support stuff 
+ 
+def _get_win_folder_from_registry(csidl_name): 
+    """This is a fallback technique at best. I'm not sure if using the 
+    registry for this guarantees us the correct answer for all CSIDL_* 
+    names. 
+    """ 
+    if PY3: 
+      import winreg as _winreg 
+    else: 
+      import _winreg 
+ 
+    shell_folder_name = { 
+        "CSIDL_APPDATA": "AppData", 
+        "CSIDL_COMMON_APPDATA": "Common AppData", 
+        "CSIDL_LOCAL_APPDATA": "Local AppData", 
+    }[csidl_name] 
+ 
+    key = _winreg.OpenKey( 
+        _winreg.HKEY_CURRENT_USER, 
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" 
+    ) 
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name) 
+    return dir 
+ 
+ 
+def _get_win_folder_with_pywin32(csidl_name): 
+    from win32com.shell import shellcon, shell 
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0) 
+    # Try to make this a unicode path because SHGetFolderPath does 
+    # not return unicode strings when there is unicode data in the 
+    # path. 
+    try: 
+        dir = unicode(dir) 
+ 
+        # Downgrade to short path name if have highbit chars. See 
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>. 
+        has_high_char = False 
+        for c in dir: 
+            if ord(c) > 255: 
+                has_high_char = True 
+                break 
+        if has_high_char: 
+            try: 
+                import win32api 
+                dir = win32api.GetShortPathName(dir) 
+            except ImportError: 
+                pass 
+    except UnicodeError: 
+        pass 
+    return dir 
+ 
+ 
+def _get_win_folder_with_ctypes(csidl_name): 
+    import ctypes 
+ 
+    csidl_const = { 
+        "CSIDL_APPDATA": 26, 
+        "CSIDL_COMMON_APPDATA": 35, 
+        "CSIDL_LOCAL_APPDATA": 28, 
+    }[csidl_name] 
+ 
+    buf = ctypes.create_unicode_buffer(1024) 
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf) 
+ 
+    # Downgrade to short path name if have highbit chars. See 
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>. 
+    has_high_char = False 
+    for c in buf: 
+        if ord(c) > 255: 
+            has_high_char = True 
+            break 
+    if has_high_char: 
+        buf2 = ctypes.create_unicode_buffer(1024) 
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024): 
+            buf = buf2 
+ 
+    return buf.value 
+ 
+def _get_win_folder_with_jna(csidl_name): 
+    import array 
+    from com.sun import jna 
+    from com.sun.jna.platform import win32 
+ 
+    buf_size = win32.WinDef.MAX_PATH * 2 
+    buf = array.zeros('c', buf_size) 
+    shell = win32.Shell32.INSTANCE 
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf) 
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0") 
+ 
+    # Downgrade to short path name if have highbit chars. See 
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>. 
+    has_high_char = False 
+    for c in dir: 
+        if ord(c) > 255: 
+            has_high_char = True 
+            break 
+    if has_high_char: 
+        buf = array.zeros('c', buf_size) 
+        kernel = win32.Kernel32.INSTANCE 
+        if kernel.GetShortPathName(dir, buf, buf_size): 
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0") 
+ 
+    return dir 
+ 
+if system == "win32": 
+    try: 
+        import win32com.shell 
+        _get_win_folder = _get_win_folder_with_pywin32 
+    except ImportError: 
+        try: 
+            from ctypes import windll 
+            _get_win_folder = _get_win_folder_with_ctypes 
+        except ImportError: 
+            try: 
+                import com.sun.jna 
+                _get_win_folder = _get_win_folder_with_jna 
+            except ImportError: 
+                _get_win_folder = _get_win_folder_from_registry 
+ 
+ 
+#---- self test code 
+ 
+if __name__ == "__main__": 
+    appname = "MyApp" 
+    appauthor = "MyCompany" 
+ 
+    props = ("user_data_dir", 
+             "user_config_dir", 
+             "user_cache_dir", 
+             "user_state_dir", 
+             "user_log_dir", 
+             "site_data_dir", 
+             "site_config_dir") 
+ 
+    print("-- app dirs %s --" % __version__) 
+ 
+    print("-- app dirs (with optional 'version')") 
+    dirs = AppDirs(appname, appauthor, version="1.0") 
+    for prop in props: 
+        print("%s: %s" % (prop, getattr(dirs, prop))) 
+ 
+    print("\n-- app dirs (without optional 'version')") 
+    dirs = AppDirs(appname, appauthor) 
+    for prop in props: 
+        print("%s: %s" % (prop, getattr(dirs, prop))) 
+ 
+    print("\n-- app dirs (without optional 'appauthor')") 
+    dirs = AppDirs(appname) 
+    for prop in props: 
+        print("%s: %s" % (prop, getattr(dirs, prop))) 
+ 
+    print("\n-- app dirs (with disabled 'appauthor')") 
+    dirs = AppDirs(appname, appauthor=False) 
+    for prop in props: 
+        print("%s: %s" % (prop, getattr(dirs, prop))) 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__about__.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__about__.py
index 95d330ef82..d6789e22c9 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__about__.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__about__.py
@@ -1,21 +1,21 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-__all__ = [
-    "__title__", "__summary__", "__uri__", "__version__", "__author__",
-    "__email__", "__license__", "__copyright__",
-]
-
-__title__ = "packaging"
-__summary__ = "Core utilities for Python packages"
-__uri__ = "https://github.com/pypa/packaging"
-
-__version__ = "16.8"
-
-__author__ = "Donald Stufft and individual contributors"
-__email__ = "donald@stufft.io"
-
-__license__ = "BSD or Apache License, Version 2.0"
-__copyright__ = "Copyright 2014-2016 %s" % __author__
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+__all__ = [ 
+    "__title__", "__summary__", "__uri__", "__version__", "__author__", 
+    "__email__", "__license__", "__copyright__", 
+] 
+ 
+__title__ = "packaging" 
+__summary__ = "Core utilities for Python packages" 
+__uri__ = "https://github.com/pypa/packaging" 
+ 
+__version__ = "16.8" 
+ 
+__author__ = "Donald Stufft and individual contributors" 
+__email__ = "donald@stufft.io" 
+ 
+__license__ = "BSD or Apache License, Version 2.0" 
+__copyright__ = "Copyright 2014-2016 %s" % __author__ 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__init__.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__init__.py
index 5ee6220203..49ad6771d4 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__init__.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/__init__.py
@@ -1,14 +1,14 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-from .__about__ import (
-    __author__, __copyright__, __email__, __license__, __summary__, __title__,
-    __uri__, __version__
-)
-
-__all__ = [
-    "__title__", "__summary__", "__uri__", "__version__", "__author__",
-    "__email__", "__license__", "__copyright__",
-]
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+from .__about__ import ( 
+    __author__, __copyright__, __email__, __license__, __summary__, __title__, 
+    __uri__, __version__ 
+) 
+ 
+__all__ = [ 
+    "__title__", "__summary__", "__uri__", "__version__", "__author__", 
+    "__email__", "__license__", "__copyright__", 
+] 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_compat.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_compat.py
index 210bb80b7e..bef4464d50 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_compat.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_compat.py
@@ -1,30 +1,30 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import sys
-
-
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-
-# flake8: noqa
-
-if PY3:
-    string_types = str,
-else:
-    string_types = basestring,
-
-
-def with_metaclass(meta, *bases):
-    """
-    Create a base class with a metaclass.
-    """
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
-    class metaclass(meta):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import sys 
+ 
+ 
+PY2 = sys.version_info[0] == 2 
+PY3 = sys.version_info[0] == 3 
+ 
+# flake8: noqa 
+ 
+if PY3: 
+    string_types = str, 
+else: 
+    string_types = basestring, 
+ 
+ 
+def with_metaclass(meta, *bases): 
+    """ 
+    Create a base class with a metaclass. 
+    """ 
+    # This requires a bit of explanation: the basic idea is to make a dummy 
+    # metaclass for one level of class instantiation that replaces itself with 
+    # the actual metaclass. 
+    class metaclass(meta): 
+        def __new__(cls, name, this_bases, d): 
+            return meta(name, bases, d) 
+    return type.__new__(metaclass, 'temporary_class', (), {}) 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_structures.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_structures.py
index ccc27861c3..1943a9cc5c 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_structures.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/_structures.py
@@ -1,68 +1,68 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-
-class Infinity(object):
-
-    def __repr__(self):
-        return "Infinity"
-
-    def __hash__(self):
-        return hash(repr(self))
-
-    def __lt__(self, other):
-        return False
-
-    def __le__(self, other):
-        return False
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
-        return True
-
-    def __ge__(self, other):
-        return True
-
-    def __neg__(self):
-        return NegativeInfinity
-
-Infinity = Infinity()
-
-
-class NegativeInfinity(object):
-
-    def __repr__(self):
-        return "-Infinity"
-
-    def __hash__(self):
-        return hash(repr(self))
-
-    def __lt__(self, other):
-        return True
-
-    def __le__(self, other):
-        return True
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
-        return False
-
-    def __ge__(self, other):
-        return False
-
-    def __neg__(self):
-        return Infinity
-
-NegativeInfinity = NegativeInfinity()
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+ 
+class Infinity(object): 
+ 
+    def __repr__(self): 
+        return "Infinity" 
+ 
+    def __hash__(self): 
+        return hash(repr(self)) 
+ 
+    def __lt__(self, other): 
+        return False 
+ 
+    def __le__(self, other): 
+        return False 
+ 
+    def __eq__(self, other): 
+        return isinstance(other, self.__class__) 
+ 
+    def __ne__(self, other): 
+        return not isinstance(other, self.__class__) 
+ 
+    def __gt__(self, other): 
+        return True 
+ 
+    def __ge__(self, other): 
+        return True 
+ 
+    def __neg__(self): 
+        return NegativeInfinity 
+ 
+Infinity = Infinity() 
+ 
+ 
+class NegativeInfinity(object): 
+ 
+    def __repr__(self): 
+        return "-Infinity" 
+ 
+    def __hash__(self): 
+        return hash(repr(self)) 
+ 
+    def __lt__(self, other): 
+        return True 
+ 
+    def __le__(self, other): 
+        return True 
+ 
+    def __eq__(self, other): 
+        return isinstance(other, self.__class__) 
+ 
+    def __ne__(self, other): 
+        return not isinstance(other, self.__class__) 
+ 
+    def __gt__(self, other): 
+        return False 
+ 
+    def __ge__(self, other): 
+        return False 
+ 
+    def __neg__(self): 
+        return Infinity 
+ 
+NegativeInfinity = NegativeInfinity() 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/markers.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/markers.py
index 892e578edd..d1df892c89 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/markers.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/markers.py
@@ -1,301 +1,301 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import operator
-import os
-import platform
-import sys
-
-from pkg_resources.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd
-from pkg_resources.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString
-from pkg_resources.extern.pyparsing import Literal as L  # noqa
-
-from ._compat import string_types
-from .specifiers import Specifier, InvalidSpecifier
-
-
-__all__ = [
-    "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName",
-    "Marker", "default_environment",
-]
-
-
-class InvalidMarker(ValueError):
-    """
-    An invalid marker was found, users should refer to PEP 508.
-    """
-
-
-class UndefinedComparison(ValueError):
-    """
-    An invalid operation was attempted on a value that doesn't support it.
-    """
-
-
-class UndefinedEnvironmentName(ValueError):
-    """
-    A name was attempted to be used that does not exist inside of the
-    environment.
-    """
-
-
-class Node(object):
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return str(self.value)
-
-    def __repr__(self):
-        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
-
-    def serialize(self):
-        raise NotImplementedError
-
-
-class Variable(Node):
-
-    def serialize(self):
-        return str(self)
-
-
-class Value(Node):
-
-    def serialize(self):
-        return '"{0}"'.format(self)
-
-
-class Op(Node):
-
-    def serialize(self):
-        return str(self)
-
-
-VARIABLE = (
-    L("implementation_version") |
-    L("platform_python_implementation") |
-    L("implementation_name") |
-    L("python_full_version") |
-    L("platform_release") |
-    L("platform_version") |
-    L("platform_machine") |
-    L("platform_system") |
-    L("python_version") |
-    L("sys_platform") |
-    L("os_name") |
-    L("os.name") |  # PEP-345
-    L("sys.platform") |  # PEP-345
-    L("platform.version") |  # PEP-345
-    L("platform.machine") |  # PEP-345
-    L("platform.python_implementation") |  # PEP-345
-    L("python_implementation") |  # undocumented setuptools legacy
-    L("extra")
-)
-ALIASES = {
-    'os.name': 'os_name',
-    'sys.platform': 'sys_platform',
-    'platform.version': 'platform_version',
-    'platform.machine': 'platform_machine',
-    'platform.python_implementation': 'platform_python_implementation',
-    'python_implementation': 'platform_python_implementation'
-}
-VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
-
-VERSION_CMP = (
-    L("===") |
-    L("==") |
-    L(">=") |
-    L("<=") |
-    L("!=") |
-    L("~=") |
-    L(">") |
-    L("<")
-)
-
-MARKER_OP = VERSION_CMP | L("not in") | L("in")
-MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
-
-MARKER_VALUE = QuotedString("'") | QuotedString('"')
-MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
-
-BOOLOP = L("and") | L("or")
-
-MARKER_VAR = VARIABLE | MARKER_VALUE
-
-MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
-MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
-
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-
-MARKER_EXPR = Forward()
-MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
-MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
-
-MARKER = stringStart + MARKER_EXPR + stringEnd
-
-
-def _coerce_parse_result(results):
-    if isinstance(results, ParseResults):
-        return [_coerce_parse_result(i) for i in results]
-    else:
-        return results
-
-
-def _format_marker(marker, first=True):
-    assert isinstance(marker, (list, tuple, string_types))
-
-    # Sometimes we have a structure like [[...]] which is a single item list
-    # where the single item is itself it's own list. In that case we want skip
-    # the rest of this function so that we don't get extraneous () on the
-    # outside.
-    if (isinstance(marker, list) and len(marker) == 1 and
-            isinstance(marker[0], (list, tuple))):
-        return _format_marker(marker[0])
-
-    if isinstance(marker, list):
-        inner = (_format_marker(m, first=False) for m in marker)
-        if first:
-            return " ".join(inner)
-        else:
-            return "(" + " ".join(inner) + ")"
-    elif isinstance(marker, tuple):
-        return " ".join([m.serialize() for m in marker])
-    else:
-        return marker
-
-
-_operators = {
-    "in": lambda lhs, rhs: lhs in rhs,
-    "not in": lambda lhs, rhs: lhs not in rhs,
-    "<": operator.lt,
-    "<=": operator.le,
-    "==": operator.eq,
-    "!=": operator.ne,
-    ">=": operator.ge,
-    ">": operator.gt,
-}
-
-
-def _eval_op(lhs, op, rhs):
-    try:
-        spec = Specifier("".join([op.serialize(), rhs]))
-    except InvalidSpecifier:
-        pass
-    else:
-        return spec.contains(lhs)
-
-    oper = _operators.get(op.serialize())
-    if oper is None:
-        raise UndefinedComparison(
-            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
-        )
-
-    return oper(lhs, rhs)
-
-
-_undefined = object()
-
-
-def _get_env(environment, name):
-    value = environment.get(name, _undefined)
-
-    if value is _undefined:
-        raise UndefinedEnvironmentName(
-            "{0!r} does not exist in evaluation environment.".format(name)
-        )
-
-    return value
-
-
-def _evaluate_markers(markers, environment):
-    groups = [[]]
-
-    for marker in markers:
-        assert isinstance(marker, (list, tuple, string_types))
-
-        if isinstance(marker, list):
-            groups[-1].append(_evaluate_markers(marker, environment))
-        elif isinstance(marker, tuple):
-            lhs, op, rhs = marker
-
-            if isinstance(lhs, Variable):
-                lhs_value = _get_env(environment, lhs.value)
-                rhs_value = rhs.value
-            else:
-                lhs_value = lhs.value
-                rhs_value = _get_env(environment, rhs.value)
-
-            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
-        else:
-            assert marker in ["and", "or"]
-            if marker == "or":
-                groups.append([])
-
-    return any(all(item) for item in groups)
-
-
-def format_full_version(info):
-    version = '{0.major}.{0.minor}.{0.micro}'.format(info)
-    kind = info.releaselevel
-    if kind != 'final':
-        version += kind[0] + str(info.serial)
-    return version
-
-
-def default_environment():
-    if hasattr(sys, 'implementation'):
-        iver = format_full_version(sys.implementation.version)
-        implementation_name = sys.implementation.name
-    else:
-        iver = '0'
-        implementation_name = ''
-
-    return {
-        "implementation_name": implementation_name,
-        "implementation_version": iver,
-        "os_name": os.name,
-        "platform_machine": platform.machine(),
-        "platform_release": platform.release(),
-        "platform_system": platform.system(),
-        "platform_version": platform.version(),
-        "python_full_version": platform.python_version(),
-        "platform_python_implementation": platform.python_implementation(),
-        "python_version": platform.python_version()[:3],
-        "sys_platform": sys.platform,
-    }
-
-
-class Marker(object):
-
-    def __init__(self, marker):
-        try:
-            self._markers = _coerce_parse_result(MARKER.parseString(marker))
-        except ParseException as e:
-            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
-                marker, marker[e.loc:e.loc + 8])
-            raise InvalidMarker(err_str)
-
-    def __str__(self):
-        return _format_marker(self._markers)
-
-    def __repr__(self):
-        return "<Marker({0!r})>".format(str(self))
-
-    def evaluate(self, environment=None):
-        """Evaluate a marker.
-
-        Return the boolean from evaluating the given marker against the
-        environment. environment is an optional argument to override all or
-        part of the determined environment.
-
-        The environment is determined from the current Python process.
-        """
-        current_environment = default_environment()
-        if environment is not None:
-            current_environment.update(environment)
-
-        return _evaluate_markers(self._markers, current_environment)
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import operator 
+import os 
+import platform 
+import sys 
+ 
+from pkg_resources.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd 
+from pkg_resources.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString 
+from pkg_resources.extern.pyparsing import Literal as L  # noqa 
+ 
+from ._compat import string_types 
+from .specifiers import Specifier, InvalidSpecifier 
+ 
+ 
+__all__ = [ 
+    "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName", 
+    "Marker", "default_environment", 
+] 
+ 
+ 
+class InvalidMarker(ValueError): 
+    """ 
+    An invalid marker was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+class UndefinedComparison(ValueError): 
+    """ 
+    An invalid operation was attempted on a value that doesn't support it. 
+    """ 
+ 
+ 
+class UndefinedEnvironmentName(ValueError): 
+    """ 
+    A name was attempted to be used that does not exist inside of the 
+    environment. 
+    """ 
+ 
+ 
+class Node(object): 
+ 
+    def __init__(self, value): 
+        self.value = value 
+ 
+    def __str__(self): 
+        return str(self.value) 
+ 
+    def __repr__(self): 
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self)) 
+ 
+    def serialize(self): 
+        raise NotImplementedError 
+ 
+ 
+class Variable(Node): 
+ 
+    def serialize(self): 
+        return str(self) 
+ 
+ 
+class Value(Node): 
+ 
+    def serialize(self): 
+        return '"{0}"'.format(self) 
+ 
+ 
+class Op(Node): 
+ 
+    def serialize(self): 
+        return str(self) 
+ 
+ 
+VARIABLE = ( 
+    L("implementation_version") | 
+    L("platform_python_implementation") | 
+    L("implementation_name") | 
+    L("python_full_version") | 
+    L("platform_release") | 
+    L("platform_version") | 
+    L("platform_machine") | 
+    L("platform_system") | 
+    L("python_version") | 
+    L("sys_platform") | 
+    L("os_name") | 
+    L("os.name") |  # PEP-345 
+    L("sys.platform") |  # PEP-345 
+    L("platform.version") |  # PEP-345 
+    L("platform.machine") |  # PEP-345 
+    L("platform.python_implementation") |  # PEP-345 
+    L("python_implementation") |  # undocumented setuptools legacy 
+    L("extra") 
+) 
+ALIASES = { 
+    'os.name': 'os_name', 
+    'sys.platform': 'sys_platform', 
+    'platform.version': 'platform_version', 
+    'platform.machine': 'platform_machine', 
+    'platform.python_implementation': 'platform_python_implementation', 
+    'python_implementation': 'platform_python_implementation' 
+} 
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0]))) 
+ 
+VERSION_CMP = ( 
+    L("===") | 
+    L("==") | 
+    L(">=") | 
+    L("<=") | 
+    L("!=") | 
+    L("~=") | 
+    L(">") | 
+    L("<") 
+) 
+ 
+MARKER_OP = VERSION_CMP | L("not in") | L("in") 
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0])) 
+ 
+MARKER_VALUE = QuotedString("'") | QuotedString('"') 
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0])) 
+ 
+BOOLOP = L("and") | L("or") 
+ 
+MARKER_VAR = VARIABLE | MARKER_VALUE 
+ 
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR) 
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0])) 
+ 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+ 
+MARKER_EXPR = Forward() 
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN) 
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR) 
+ 
+MARKER = stringStart + MARKER_EXPR + stringEnd 
+ 
+ 
+def _coerce_parse_result(results): 
+    if isinstance(results, ParseResults): 
+        return [_coerce_parse_result(i) for i in results] 
+    else: 
+        return results 
+ 
+ 
+def _format_marker(marker, first=True): 
+    assert isinstance(marker, (list, tuple, string_types)) 
+ 
+    # Sometimes we have a structure like [[...]] which is a single item list 
+    # where the single item is itself it's own list. In that case we want skip 
+    # the rest of this function so that we don't get extraneous () on the 
+    # outside. 
+    if (isinstance(marker, list) and len(marker) == 1 and 
+            isinstance(marker[0], (list, tuple))): 
+        return _format_marker(marker[0]) 
+ 
+    if isinstance(marker, list): 
+        inner = (_format_marker(m, first=False) for m in marker) 
+        if first: 
+            return " ".join(inner) 
+        else: 
+            return "(" + " ".join(inner) + ")" 
+    elif isinstance(marker, tuple): 
+        return " ".join([m.serialize() for m in marker]) 
+    else: 
+        return marker 
+ 
+ 
+_operators = { 
+    "in": lambda lhs, rhs: lhs in rhs, 
+    "not in": lambda lhs, rhs: lhs not in rhs, 
+    "<": operator.lt, 
+    "<=": operator.le, 
+    "==": operator.eq, 
+    "!=": operator.ne, 
+    ">=": operator.ge, 
+    ">": operator.gt, 
+} 
+ 
+ 
+def _eval_op(lhs, op, rhs): 
+    try: 
+        spec = Specifier("".join([op.serialize(), rhs])) 
+    except InvalidSpecifier: 
+        pass 
+    else: 
+        return spec.contains(lhs) 
+ 
+    oper = _operators.get(op.serialize()) 
+    if oper is None: 
+        raise UndefinedComparison( 
+            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs) 
+        ) 
+ 
+    return oper(lhs, rhs) 
+ 
+ 
+_undefined = object() 
+ 
+ 
+def _get_env(environment, name): 
+    value = environment.get(name, _undefined) 
+ 
+    if value is _undefined: 
+        raise UndefinedEnvironmentName( 
+            "{0!r} does not exist in evaluation environment.".format(name) 
+        ) 
+ 
+    return value 
+ 
+ 
+def _evaluate_markers(markers, environment): 
+    groups = [[]] 
+ 
+    for marker in markers: 
+        assert isinstance(marker, (list, tuple, string_types)) 
+ 
+        if isinstance(marker, list): 
+            groups[-1].append(_evaluate_markers(marker, environment)) 
+        elif isinstance(marker, tuple): 
+            lhs, op, rhs = marker 
+ 
+            if isinstance(lhs, Variable): 
+                lhs_value = _get_env(environment, lhs.value) 
+                rhs_value = rhs.value 
+            else: 
+                lhs_value = lhs.value 
+                rhs_value = _get_env(environment, rhs.value) 
+ 
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value)) 
+        else: 
+            assert marker in ["and", "or"] 
+            if marker == "or": 
+                groups.append([]) 
+ 
+    return any(all(item) for item in groups) 
+ 
+ 
+def format_full_version(info): 
+    version = '{0.major}.{0.minor}.{0.micro}'.format(info) 
+    kind = info.releaselevel 
+    if kind != 'final': 
+        version += kind[0] + str(info.serial) 
+    return version 
+ 
+ 
+def default_environment(): 
+    if hasattr(sys, 'implementation'): 
+        iver = format_full_version(sys.implementation.version) 
+        implementation_name = sys.implementation.name 
+    else: 
+        iver = '0' 
+        implementation_name = '' 
+ 
+    return { 
+        "implementation_name": implementation_name, 
+        "implementation_version": iver, 
+        "os_name": os.name, 
+        "platform_machine": platform.machine(), 
+        "platform_release": platform.release(), 
+        "platform_system": platform.system(), 
+        "platform_version": platform.version(), 
+        "python_full_version": platform.python_version(), 
+        "platform_python_implementation": platform.python_implementation(), 
+        "python_version": platform.python_version()[:3], 
+        "sys_platform": sys.platform, 
+    } 
+ 
+ 
+class Marker(object): 
+ 
+    def __init__(self, marker): 
+        try: 
+            self._markers = _coerce_parse_result(MARKER.parseString(marker)) 
+        except ParseException as e: 
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format( 
+                marker, marker[e.loc:e.loc + 8]) 
+            raise InvalidMarker(err_str) 
+ 
+    def __str__(self): 
+        return _format_marker(self._markers) 
+ 
+    def __repr__(self): 
+        return "<Marker({0!r})>".format(str(self)) 
+ 
+    def evaluate(self, environment=None): 
+        """Evaluate a marker. 
+ 
+        Return the boolean from evaluating the given marker against the 
+        environment. environment is an optional argument to override all or 
+        part of the determined environment. 
+ 
+        The environment is determined from the current Python process. 
+        """ 
+        current_environment = default_environment() 
+        if environment is not None: 
+            current_environment.update(environment) 
+ 
+        return _evaluate_markers(self._markers, current_environment) 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/requirements.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/requirements.py
index 0c8c4a3852..79391d96c3 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/requirements.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/requirements.py
@@ -1,127 +1,127 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import string
-import re
-
-from pkg_resources.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
-from pkg_resources.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
-from pkg_resources.extern.pyparsing import Literal as L  # noqa
-from pkg_resources.extern.six.moves.urllib import parse as urlparse
-
-from .markers import MARKER_EXPR, Marker
-from .specifiers import LegacySpecifier, Specifier, SpecifierSet
-
-
-class InvalidRequirement(ValueError):
-    """
-    An invalid requirement was found, users should refer to PEP 508.
-    """
-
-
-ALPHANUM = Word(string.ascii_letters + string.digits)
-
-LBRACKET = L("[").suppress()
-RBRACKET = L("]").suppress()
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-COMMA = L(",").suppress()
-SEMICOLON = L(";").suppress()
-AT = L("@").suppress()
-
-PUNCTUATION = Word("-_.")
-IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
-IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
-
-NAME = IDENTIFIER("name")
-EXTRA = IDENTIFIER
-
-URI = Regex(r'[^ ]+')("url")
-URL = (AT + URI)
-
-EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
-EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
-
-VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
-VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
-
-VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
-VERSION_MANY = Combine(VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE),
-                       joinString=",", adjacent=False)("_raw_spec")
-_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
-_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or '')
-
-VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
-VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
-
-MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
-MARKER_EXPR.setParseAction(
-    lambda s, l, t: Marker(s[t._original_start:t._original_end])
-)
-MARKER_SEPERATOR = SEMICOLON
-MARKER = MARKER_SEPERATOR + MARKER_EXPR
-
-VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
-URL_AND_MARKER = URL + Optional(MARKER)
-
-NAMED_REQUIREMENT = \
-    NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
-
-REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
-
-
-class Requirement(object):
-    """Parse a requirement.
-
-    Parse a given requirement string into its parts, such as name, specifier,
-    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
-    string.
-    """
-
-    # TODO: Can we test whether something is contained within a requirement?
-    #       If so how do we do that? Do we need to test against the _name_ of
-    #       the thing as well as the version? What about the markers?
-    # TODO: Can we normalize the name and extra name?
-
-    def __init__(self, requirement_string):
-        try:
-            req = REQUIREMENT.parseString(requirement_string)
-        except ParseException as e:
-            raise InvalidRequirement(
-                "Invalid requirement, parse error at \"{0!r}\"".format(
-                    requirement_string[e.loc:e.loc + 8]))
-
-        self.name = req.name
-        if req.url:
-            parsed_url = urlparse.urlparse(req.url)
-            if not (parsed_url.scheme and parsed_url.netloc) or (
-                    not parsed_url.scheme and not parsed_url.netloc):
-                raise InvalidRequirement("Invalid URL given")
-            self.url = req.url
-        else:
-            self.url = None
-        self.extras = set(req.extras.asList() if req.extras else [])
-        self.specifier = SpecifierSet(req.specifier)
-        self.marker = req.marker if req.marker else None
-
-    def __str__(self):
-        parts = [self.name]
-
-        if self.extras:
-            parts.append("[{0}]".format(",".join(sorted(self.extras))))
-
-        if self.specifier:
-            parts.append(str(self.specifier))
-
-        if self.url:
-            parts.append("@ {0}".format(self.url))
-
-        if self.marker:
-            parts.append("; {0}".format(self.marker))
-
-        return "".join(parts)
-
-    def __repr__(self):
-        return "<Requirement({0!r})>".format(str(self))
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import string 
+import re 
+ 
+from pkg_resources.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException 
+from pkg_resources.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine 
+from pkg_resources.extern.pyparsing import Literal as L  # noqa 
+from pkg_resources.extern.six.moves.urllib import parse as urlparse 
+ 
+from .markers import MARKER_EXPR, Marker 
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet 
+ 
+ 
+class InvalidRequirement(ValueError): 
+    """ 
+    An invalid requirement was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+ALPHANUM = Word(string.ascii_letters + string.digits) 
+ 
+LBRACKET = L("[").suppress() 
+RBRACKET = L("]").suppress() 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+COMMA = L(",").suppress() 
+SEMICOLON = L(";").suppress() 
+AT = L("@").suppress() 
+ 
+PUNCTUATION = Word("-_.") 
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM) 
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END)) 
+ 
+NAME = IDENTIFIER("name") 
+EXTRA = IDENTIFIER 
+ 
+URI = Regex(r'[^ ]+')("url") 
+URL = (AT + URI) 
+ 
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA) 
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras") 
+ 
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+ 
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY 
+VERSION_MANY = Combine(VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), 
+                       joinString=",", adjacent=False)("_raw_spec") 
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY)) 
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or '') 
+ 
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier") 
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1]) 
+ 
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker") 
+MARKER_EXPR.setParseAction( 
+    lambda s, l, t: Marker(s[t._original_start:t._original_end]) 
+) 
+MARKER_SEPERATOR = SEMICOLON 
+MARKER = MARKER_SEPERATOR + MARKER_EXPR 
+ 
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER) 
+URL_AND_MARKER = URL + Optional(MARKER) 
+ 
+NAMED_REQUIREMENT = \ 
+    NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER) 
+ 
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd 
+ 
+ 
+class Requirement(object): 
+    """Parse a requirement. 
+ 
+    Parse a given requirement string into its parts, such as name, specifier, 
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement 
+    string. 
+    """ 
+ 
+    # TODO: Can we test whether something is contained within a requirement? 
+    #       If so how do we do that? Do we need to test against the _name_ of 
+    #       the thing as well as the version? What about the markers? 
+    # TODO: Can we normalize the name and extra name? 
+ 
+    def __init__(self, requirement_string): 
+        try: 
+            req = REQUIREMENT.parseString(requirement_string) 
+        except ParseException as e: 
+            raise InvalidRequirement( 
+                "Invalid requirement, parse error at \"{0!r}\"".format( 
+                    requirement_string[e.loc:e.loc + 8])) 
+ 
+        self.name = req.name 
+        if req.url: 
+            parsed_url = urlparse.urlparse(req.url) 
+            if not (parsed_url.scheme and parsed_url.netloc) or ( 
+                    not parsed_url.scheme and not parsed_url.netloc): 
+                raise InvalidRequirement("Invalid URL given") 
+            self.url = req.url 
+        else: 
+            self.url = None 
+        self.extras = set(req.extras.asList() if req.extras else []) 
+        self.specifier = SpecifierSet(req.specifier) 
+        self.marker = req.marker if req.marker else None 
+ 
+    def __str__(self): 
+        parts = [self.name] 
+ 
+        if self.extras: 
+            parts.append("[{0}]".format(",".join(sorted(self.extras)))) 
+ 
+        if self.specifier: 
+            parts.append(str(self.specifier)) 
+ 
+        if self.url: 
+            parts.append("@ {0}".format(self.url)) 
+ 
+        if self.marker: 
+            parts.append("; {0}".format(self.marker)) 
+ 
+        return "".join(parts) 
+ 
+    def __repr__(self): 
+        return "<Requirement({0!r})>".format(str(self)) 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/specifiers.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/specifiers.py
index 7f5a76cfd6..e76efb8fb6 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/specifiers.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/specifiers.py
@@ -1,774 +1,774 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import abc
-import functools
-import itertools
-import re
-
-from ._compat import string_types, with_metaclass
-from .version import Version, LegacyVersion, parse
-
-
-class InvalidSpecifier(ValueError):
-    """
-    An invalid specifier was found, users should refer to PEP 440.
-    """
-
-
-class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):
-
-    @abc.abstractmethod
-    def __str__(self):
-        """
-        Returns the str representation of this Specifier like object. This
-        should be representative of the Specifier itself.
-        """
-
-    @abc.abstractmethod
-    def __hash__(self):
-        """
-        Returns a hash value for this Specifier like object.
-        """
-
-    @abc.abstractmethod
-    def __eq__(self, other):
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are equal.
-        """
-
-    @abc.abstractmethod
-    def __ne__(self, other):
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are not equal.
-        """
-
-    @abc.abstractproperty
-    def prereleases(self):
-        """
-        Returns whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @prereleases.setter
-    def prereleases(self, value):
-        """
-        Sets whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @abc.abstractmethod
-    def contains(self, item, prereleases=None):
-        """
-        Determines if the given item is contained within this specifier.
-        """
-
-    @abc.abstractmethod
-    def filter(self, iterable, prereleases=None):
-        """
-        Takes an iterable of items and filters them so that only items which
-        are contained within this specifier are allowed in it.
-        """
-
-
-class _IndividualSpecifier(BaseSpecifier):
-
-    _operators = {}
-
-    def __init__(self, spec="", prereleases=None):
-        match = self._regex.search(spec)
-        if not match:
-            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
-
-        self._spec = (
-            match.group("operator").strip(),
-            match.group("version").strip(),
-        )
-
-        # Store whether or not this Specifier should accept prereleases
-        self._prereleases = prereleases
-
-    def __repr__(self):
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
-        return "<{0}({1!r}{2})>".format(
-            self.__class__.__name__,
-            str(self),
-            pre,
-        )
-
-    def __str__(self):
-        return "{0}{1}".format(*self._spec)
-
-    def __hash__(self):
-        return hash(self._spec)
-
-    def __eq__(self, other):
-        if isinstance(other, string_types):
-            try:
-                other = self.__class__(other)
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._spec == other._spec
-
-    def __ne__(self, other):
-        if isinstance(other, string_types):
-            try:
-                other = self.__class__(other)
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._spec != other._spec
-
-    def _get_operator(self, op):
-        return getattr(self, "_compare_{0}".format(self._operators[op]))
-
-    def _coerce_version(self, version):
-        if not isinstance(version, (LegacyVersion, Version)):
-            version = parse(version)
-        return version
-
-    @property
-    def operator(self):
-        return self._spec[0]
-
-    @property
-    def version(self):
-        return self._spec[1]
-
-    @property
-    def prereleases(self):
-        return self._prereleases
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-    def __contains__(self, item):
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
-        # Determine if prereleases are to be allowed or not.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # Normalize item to a Version or LegacyVersion, this allows us to have
-        # a shortcut for ``"2.0" in Specifier(">=2")
-        item = self._coerce_version(item)
-
-        # Determine if we should be supporting prereleases in this specifier
-        # or not, if we do not support prereleases than we can short circuit
-        # logic if this version is a prereleases.
-        if item.is_prerelease and not prereleases:
-            return False
-
-        # Actually do the comparison to determine if this item is contained
-        # within this Specifier or not.
-        return self._get_operator(self.operator)(item, self.version)
-
-    def filter(self, iterable, prereleases=None):
-        yielded = False
-        found_prereleases = []
-
-        kw = {"prereleases": prereleases if prereleases is not None else True}
-
-        # Attempt to iterate over all the values in the iterable and if any of
-        # them match, yield them.
-        for version in iterable:
-            parsed_version = self._coerce_version(version)
-
-            if self.contains(parsed_version, **kw):
-                # If our version is a prerelease, and we were not set to allow
-                # prereleases, then we'll store it for later incase nothing
-                # else matches this specifier.
-                if (parsed_version.is_prerelease and not
-                        (prereleases or self.prereleases)):
-                    found_prereleases.append(version)
-                # Either this is not a prerelease, or we should have been
-                # accepting prereleases from the begining.
-                else:
-                    yielded = True
-                    yield version
-
-        # Now that we've iterated over everything, determine if we've yielded
-        # any values, and if we have not and we have any prereleases stored up
-        # then we will go ahead and yield the prereleases.
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
-
-
-class LegacySpecifier(_IndividualSpecifier):
-
-    _regex_str = (
-        r"""
-        (?P<operator>(==|!=|<=|>=|<|>))
-        \s*
-        (?P<version>
-            [^,;\s)]* # Since this is a "legacy" specifier, and the version
-                      # string can be just about anything, we match everything
-                      # except for whitespace, a semi-colon for marker support,
-                      # a closing paren since versions can be enclosed in
-                      # them, and a comma since it's a version separator.
-        )
-        """
-    )
-
-    _regex = re.compile(
-        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-    }
-
-    def _coerce_version(self, version):
-        if not isinstance(version, LegacyVersion):
-            version = LegacyVersion(str(version))
-        return version
-
-    def _compare_equal(self, prospective, spec):
-        return prospective == self._coerce_version(spec)
-
-    def _compare_not_equal(self, prospective, spec):
-        return prospective != self._coerce_version(spec)
-
-    def _compare_less_than_equal(self, prospective, spec):
-        return prospective <= self._coerce_version(spec)
-
-    def _compare_greater_than_equal(self, prospective, spec):
-        return prospective >= self._coerce_version(spec)
-
-    def _compare_less_than(self, prospective, spec):
-        return prospective < self._coerce_version(spec)
-
-    def _compare_greater_than(self, prospective, spec):
-        return prospective > self._coerce_version(spec)
-
-
-def _require_version_compare(fn):
-    @functools.wraps(fn)
-    def wrapped(self, prospective, spec):
-        if not isinstance(prospective, Version):
-            return False
-        return fn(self, prospective, spec)
-    return wrapped
-
-
-class Specifier(_IndividualSpecifier):
-
-    _regex_str = (
-        r"""
-        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
-        (?P<version>
-            (?:
-                # The identity operators allow for an escape hatch that will
-                # do an exact string match of the version you wish to install.
-                # This will not be parsed by PEP 440 and we cannot determine
-                # any semantic meaning from it. This operator is discouraged
-                # but included entirely as an escape hatch.
-                (?<====)  # Only match for the identity operator
-                \s*
-                [^\s]*    # We just match everything, except for whitespace
-                          # since we are only testing for strict identity.
-            )
-            |
-            (?:
-                # The (non)equality operators allow for wild card and local
-                # versions to be specified so we have to define these two
-                # operators separately to enable that.
-                (?<===|!=)            # Only match for equals and not equals
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-
-                # You cannot use a wild card and a dev or local version
-                # together so group them with a | and make them optional.
-                (?:
-                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
-                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
-                    |
-                    \.\*  # Wild card syntax of .*
-                )?
-            )
-            |
-            (?:
-                # The compatible operator requires at least two digits in the
-                # release segment.
-                (?<=~=)               # Only match for the compatible operator
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-            |
-            (?:
-                # All other operators only allow a sub set of what the
-                # (non)equality operators do. Specifically they do not allow
-                # local versions to be specified nor do they allow the prefix
-                # matching wild cards.
-                (?<!==|!=|~=)         # We have special cases for these
-                                      # operators so we want to make sure they
-                                      # don't match here.
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-        )
-        """
-    )
-
-    _regex = re.compile(
-        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "~=": "compatible",
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-        "===": "arbitrary",
-    }
-
-    @_require_version_compare
-    def _compare_compatible(self, prospective, spec):
-        # Compatible releases have an equivalent combination of >= and ==. That
-        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
-        # implement this in terms of the other specifiers instead of
-        # implementing it ourselves. The only thing we need to do is construct
-        # the other specifiers.
-
-        # We want everything but the last item in the version, but we want to
-        # ignore post and dev releases and we want to treat the pre-release as
-        # it's own separate segment.
-        prefix = ".".join(
-            list(
-                itertools.takewhile(
-                    lambda x: (not x.startswith("post") and not
-                               x.startswith("dev")),
-                    _version_split(spec),
-                )
-            )[:-1]
-        )
-
-        # Add the prefix notation to the end of our string
-        prefix += ".*"
-
-        return (self._get_operator(">=")(prospective, spec) and
-                self._get_operator("==")(prospective, prefix))
-
-    @_require_version_compare
-    def _compare_equal(self, prospective, spec):
-        # We need special logic to handle prefix matching
-        if spec.endswith(".*"):
-            # In the case of prefix matching we want to ignore local segment.
-            prospective = Version(prospective.public)
-            # Split the spec out by dots, and pretend that there is an implicit
-            # dot in between a release segment and a pre-release segment.
-            spec = _version_split(spec[:-2])  # Remove the trailing .*
-
-            # Split the prospective version out by dots, and pretend that there
-            # is an implicit dot in between a release segment and a pre-release
-            # segment.
-            prospective = _version_split(str(prospective))
-
-            # Shorten the prospective version to be the same length as the spec
-            # so that we can determine if the specifier is a prefix of the
-            # prospective version or not.
-            prospective = prospective[:len(spec)]
-
-            # Pad out our two sides with zeros so that they both equal the same
-            # length.
-            spec, prospective = _pad_version(spec, prospective)
-        else:
-            # Convert our spec string into a Version
-            spec = Version(spec)
-
-            # If the specifier does not have a local segment, then we want to
-            # act as if the prospective version also does not have a local
-            # segment.
-            if not spec.local:
-                prospective = Version(prospective.public)
-
-        return prospective == spec
-
-    @_require_version_compare
-    def _compare_not_equal(self, prospective, spec):
-        return not self._compare_equal(prospective, spec)
-
-    @_require_version_compare
-    def _compare_less_than_equal(self, prospective, spec):
-        return prospective <= Version(spec)
-
-    @_require_version_compare
-    def _compare_greater_than_equal(self, prospective, spec):
-        return prospective >= Version(spec)
-
-    @_require_version_compare
-    def _compare_less_than(self, prospective, spec):
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec)
-
-        # Check to see if the prospective version is less than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective < spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a pre-release version, that we do not accept pre-release
-        # versions for the version mentioned in the specifier (e.g. <3.1 should
-        # not match 3.1.dev0, but should match 3.0.dev0).
-        if not spec.is_prerelease and prospective.is_prerelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # less than the spec version *and* it's not a pre-release of the same
-        # version in the spec.
-        return True
-
-    @_require_version_compare
-    def _compare_greater_than(self, prospective, spec):
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec)
-
-        # Check to see if the prospective version is greater than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective > spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a post-release version, that we do not accept
-        # post-release versions for the version mentioned in the specifier
-        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
-        if not spec.is_postrelease and prospective.is_postrelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # Ensure that we do not allow a local version of the version mentioned
-        # in the specifier, which is techincally greater than, to match.
-        if prospective.local is not None:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # greater than the spec version *and* it's not a pre-release of the
-        # same version in the spec.
-        return True
-
-    def _compare_arbitrary(self, prospective, spec):
-        return str(prospective).lower() == str(spec).lower()
-
-    @property
-    def prereleases(self):
-        # If there is an explicit prereleases set for this, then we'll just
-        # blindly use that.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # Look at all of our specifiers and determine if they are inclusive
-        # operators, and if they are if they are including an explicit
-        # prerelease.
-        operator, version = self._spec
-        if operator in ["==", ">=", "<=", "~=", "==="]:
-            # The == specifier can include a trailing .*, if it does we
-            # want to remove before parsing.
-            if operator == "==" and version.endswith(".*"):
-                version = version[:-2]
-
-            # Parse the version, and if it is a pre-release than this
-            # specifier allows pre-releases.
-            if parse(version).is_prerelease:
-                return True
-
-        return False
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-
-_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
-
-
-def _version_split(version):
-    result = []
-    for item in version.split("."):
-        match = _prefix_regex.search(item)
-        if match:
-            result.extend(match.groups())
-        else:
-            result.append(item)
-    return result
-
-
-def _pad_version(left, right):
-    left_split, right_split = [], []
-
-    # Get the release segment of our versions
-    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
-    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
-
-    # Get the rest of our versions
-    left_split.append(left[len(left_split[0]):])
-    right_split.append(right[len(right_split[0]):])
-
-    # Insert our padding
-    left_split.insert(
-        1,
-        ["0"] * max(0, len(right_split[0]) - len(left_split[0])),
-    )
-    right_split.insert(
-        1,
-        ["0"] * max(0, len(left_split[0]) - len(right_split[0])),
-    )
-
-    return (
-        list(itertools.chain(*left_split)),
-        list(itertools.chain(*right_split)),
-    )
-
-
-class SpecifierSet(BaseSpecifier):
-
-    def __init__(self, specifiers="", prereleases=None):
-        # Split on , to break each indidivual specifier into it's own item, and
-        # strip each item to remove leading/trailing whitespace.
-        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
-
-        # Parsed each individual specifier, attempting first to make it a
-        # Specifier and falling back to a LegacySpecifier.
-        parsed = set()
-        for specifier in specifiers:
-            try:
-                parsed.add(Specifier(specifier))
-            except InvalidSpecifier:
-                parsed.add(LegacySpecifier(specifier))
-
-        # Turn our parsed specifiers into a frozen set and save them for later.
-        self._specs = frozenset(parsed)
-
-        # Store our prereleases value so we can use it later to determine if
-        # we accept prereleases or not.
-        self._prereleases = prereleases
-
-    def __repr__(self):
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
-        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
-
-    def __str__(self):
-        return ",".join(sorted(str(s) for s in self._specs))
-
-    def __hash__(self):
-        return hash(self._specs)
-
-    def __and__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        specifier = SpecifierSet()
-        specifier._specs = frozenset(self._specs | other._specs)
-
-        if self._prereleases is None and other._prereleases is not None:
-            specifier._prereleases = other._prereleases
-        elif self._prereleases is not None and other._prereleases is None:
-            specifier._prereleases = self._prereleases
-        elif self._prereleases == other._prereleases:
-            specifier._prereleases = self._prereleases
-        else:
-            raise ValueError(
-                "Cannot combine SpecifierSets with True and False prerelease "
-                "overrides."
-            )
-
-        return specifier
-
-    def __eq__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif isinstance(other, _IndividualSpecifier):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs == other._specs
-
-    def __ne__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif isinstance(other, _IndividualSpecifier):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs != other._specs
-
-    def __len__(self):
-        return len(self._specs)
-
-    def __iter__(self):
-        return iter(self._specs)
-
-    @property
-    def prereleases(self):
-        # If we have been given an explicit prerelease modifier, then we'll
-        # pass that through here.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # If we don't have any specifiers, and we don't have a forced value,
-        # then we'll just return None since we don't know if this should have
-        # pre-releases or not.
-        if not self._specs:
-            return None
-
-        # Otherwise we'll see if any of the given specifiers accept
-        # prereleases, if any of them do we'll return True, otherwise False.
-        return any(s.prereleases for s in self._specs)
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-    def __contains__(self, item):
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
-        # Ensure that our item is a Version or LegacyVersion instance.
-        if not isinstance(item, (LegacyVersion, Version)):
-            item = parse(item)
-
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # We can determine if we're going to allow pre-releases by looking to
-        # see if any of the underlying items supports them. If none of them do
-        # and this item is a pre-release then we do not allow it and we can
-        # short circuit that here.
-        # Note: This means that 1.0.dev1 would not be contained in something
-        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
-        if not prereleases and item.is_prerelease:
-            return False
-
-        # We simply dispatch to the underlying specs here to make sure that the
-        # given version is contained within all of them.
-        # Note: This use of all() here means that an empty set of specifiers
-        #       will always return True, this is an explicit design decision.
-        return all(
-            s.contains(item, prereleases=prereleases)
-            for s in self._specs
-        )
-
-    def filter(self, iterable, prereleases=None):
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # If we have any specifiers, then we want to wrap our iterable in the
-        # filter method for each one, this will act as a logical AND amongst
-        # each specifier.
-        if self._specs:
-            for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
-            return iterable
-        # If we do not have any specifiers, then we need to have a rough filter
-        # which will filter out any pre-releases, unless there are no final
-        # releases, and which will filter out LegacyVersion in general.
-        else:
-            filtered = []
-            found_prereleases = []
-
-            for item in iterable:
-                # Ensure that we some kind of Version class for this item.
-                if not isinstance(item, (LegacyVersion, Version)):
-                    parsed_version = parse(item)
-                else:
-                    parsed_version = item
-
-                # Filter out any item which is parsed as a LegacyVersion
-                if isinstance(parsed_version, LegacyVersion):
-                    continue
-
-                # Store any item which is a pre-release for later unless we've
-                # already found a final version or we are accepting prereleases
-                if parsed_version.is_prerelease and not prereleases:
-                    if not filtered:
-                        found_prereleases.append(item)
-                else:
-                    filtered.append(item)
-
-            # If we've found no items except for pre-releases, then we'll go
-            # ahead and use the pre-releases
-            if not filtered and found_prereleases and prereleases is None:
-                return found_prereleases
-
-            return filtered
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import abc 
+import functools 
+import itertools 
+import re 
+ 
+from ._compat import string_types, with_metaclass 
+from .version import Version, LegacyVersion, parse 
+ 
+ 
+class InvalidSpecifier(ValueError): 
+    """ 
+    An invalid specifier was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
+class BaseSpecifier(with_metaclass(abc.ABCMeta, object)): 
+ 
+    @abc.abstractmethod 
+    def __str__(self): 
+        """ 
+        Returns the str representation of this Specifier like object. This 
+        should be representative of the Specifier itself. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __hash__(self): 
+        """ 
+        Returns a hash value for this Specifier like object. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __eq__(self, other): 
+        """ 
+        Returns a boolean representing whether or not the two Specifier like 
+        objects are equal. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __ne__(self, other): 
+        """ 
+        Returns a boolean representing whether or not the two Specifier like 
+        objects are not equal. 
+        """ 
+ 
+    @abc.abstractproperty 
+    def prereleases(self): 
+        """ 
+        Returns whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        """ 
+        Sets whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def contains(self, item, prereleases=None): 
+        """ 
+        Determines if the given item is contained within this specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def filter(self, iterable, prereleases=None): 
+        """ 
+        Takes an iterable of items and filters them so that only items which 
+        are contained within this specifier are allowed in it. 
+        """ 
+ 
+ 
+class _IndividualSpecifier(BaseSpecifier): 
+ 
+    _operators = {} 
+ 
+    def __init__(self, spec="", prereleases=None): 
+        match = self._regex.search(spec) 
+        if not match: 
+            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec)) 
+ 
+        self._spec = ( 
+            match.group("operator").strip(), 
+            match.group("version").strip(), 
+        ) 
+ 
+        # Store whether or not this Specifier should accept prereleases 
+        self._prereleases = prereleases 
+ 
+    def __repr__(self): 
+        pre = ( 
+            ", prereleases={0!r}".format(self.prereleases) 
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
+        return "<{0}({1!r}{2})>".format( 
+            self.__class__.__name__, 
+            str(self), 
+            pre, 
+        ) 
+ 
+    def __str__(self): 
+        return "{0}{1}".format(*self._spec) 
+ 
+    def __hash__(self): 
+        return hash(self._spec) 
+ 
+    def __eq__(self, other): 
+        if isinstance(other, string_types): 
+            try: 
+                other = self.__class__(other) 
+            except InvalidSpecifier: 
+                return NotImplemented 
+        elif not isinstance(other, self.__class__): 
+            return NotImplemented 
+ 
+        return self._spec == other._spec 
+ 
+    def __ne__(self, other): 
+        if isinstance(other, string_types): 
+            try: 
+                other = self.__class__(other) 
+            except InvalidSpecifier: 
+                return NotImplemented 
+        elif not isinstance(other, self.__class__): 
+            return NotImplemented 
+ 
+        return self._spec != other._spec 
+ 
+    def _get_operator(self, op): 
+        return getattr(self, "_compare_{0}".format(self._operators[op])) 
+ 
+    def _coerce_version(self, version): 
+        if not isinstance(version, (LegacyVersion, Version)): 
+            version = parse(version) 
+        return version 
+ 
+    @property 
+    def operator(self): 
+        return self._spec[0] 
+ 
+    @property 
+    def version(self): 
+        return self._spec[1] 
+ 
+    @property 
+    def prereleases(self): 
+        return self._prereleases 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        self._prereleases = value 
+ 
+    def __contains__(self, item): 
+        return self.contains(item) 
+ 
+    def contains(self, item, prereleases=None): 
+        # Determine if prereleases are to be allowed or not. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # Normalize item to a Version or LegacyVersion, this allows us to have 
+        # a shortcut for ``"2.0" in Specifier(">=2") 
+        item = self._coerce_version(item) 
+ 
+        # Determine if we should be supporting prereleases in this specifier 
+        # or not, if we do not support prereleases than we can short circuit 
+        # logic if this version is a prereleases. 
+        if item.is_prerelease and not prereleases: 
+            return False 
+ 
+        # Actually do the comparison to determine if this item is contained 
+        # within this Specifier or not. 
+        return self._get_operator(self.operator)(item, self.version) 
+ 
+    def filter(self, iterable, prereleases=None): 
+        yielded = False 
+        found_prereleases = [] 
+ 
+        kw = {"prereleases": prereleases if prereleases is not None else True} 
+ 
+        # Attempt to iterate over all the values in the iterable and if any of 
+        # them match, yield them. 
+        for version in iterable: 
+            parsed_version = self._coerce_version(version) 
+ 
+            if self.contains(parsed_version, **kw): 
+                # If our version is a prerelease, and we were not set to allow 
+                # prereleases, then we'll store it for later incase nothing 
+                # else matches this specifier. 
+                if (parsed_version.is_prerelease and not 
+                        (prereleases or self.prereleases)): 
+                    found_prereleases.append(version) 
+                # Either this is not a prerelease, or we should have been 
+                # accepting prereleases from the begining. 
+                else: 
+                    yielded = True 
+                    yield version 
+ 
+        # Now that we've iterated over everything, determine if we've yielded 
+        # any values, and if we have not and we have any prereleases stored up 
+        # then we will go ahead and yield the prereleases. 
+        if not yielded and found_prereleases: 
+            for version in found_prereleases: 
+                yield version 
+ 
+ 
+class LegacySpecifier(_IndividualSpecifier): 
+ 
+    _regex_str = ( 
+        r""" 
+        (?P<operator>(==|!=|<=|>=|<|>)) 
+        \s* 
+        (?P<version> 
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version 
+                      # string can be just about anything, we match everything 
+                      # except for whitespace, a semi-colon for marker support, 
+                      # a closing paren since versions can be enclosed in 
+                      # them, and a comma since it's a version separator. 
+        ) 
+        """ 
+    ) 
+ 
+    _regex = re.compile( 
+        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE) 
+ 
+    _operators = { 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+    } 
+ 
+    def _coerce_version(self, version): 
+        if not isinstance(version, LegacyVersion): 
+            version = LegacyVersion(str(version)) 
+        return version 
+ 
+    def _compare_equal(self, prospective, spec): 
+        return prospective == self._coerce_version(spec) 
+ 
+    def _compare_not_equal(self, prospective, spec): 
+        return prospective != self._coerce_version(spec) 
+ 
+    def _compare_less_than_equal(self, prospective, spec): 
+        return prospective <= self._coerce_version(spec) 
+ 
+    def _compare_greater_than_equal(self, prospective, spec): 
+        return prospective >= self._coerce_version(spec) 
+ 
+    def _compare_less_than(self, prospective, spec): 
+        return prospective < self._coerce_version(spec) 
+ 
+    def _compare_greater_than(self, prospective, spec): 
+        return prospective > self._coerce_version(spec) 
+ 
+ 
+def _require_version_compare(fn): 
+    @functools.wraps(fn) 
+    def wrapped(self, prospective, spec): 
+        if not isinstance(prospective, Version): 
+            return False 
+        return fn(self, prospective, spec) 
+    return wrapped 
+ 
+ 
+class Specifier(_IndividualSpecifier): 
+ 
+    _regex_str = ( 
+        r""" 
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===)) 
+        (?P<version> 
+            (?: 
+                # The identity operators allow for an escape hatch that will 
+                # do an exact string match of the version you wish to install. 
+                # This will not be parsed by PEP 440 and we cannot determine 
+                # any semantic meaning from it. This operator is discouraged 
+                # but included entirely as an escape hatch. 
+                (?<====)  # Only match for the identity operator 
+                \s* 
+                [^\s]*    # We just match everything, except for whitespace 
+                          # since we are only testing for strict identity. 
+            ) 
+            | 
+            (?: 
+                # The (non)equality operators allow for wild card and local 
+                # versions to be specified so we have to define these two 
+                # operators separately to enable that. 
+                (?<===|!=)            # Only match for equals and not equals 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+ 
+                # You cannot use a wild card and a dev or local version 
+                # together so group them with a | and make them optional. 
+                (?: 
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release 
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local 
+                    | 
+                    \.\*  # Wild card syntax of .* 
+                )? 
+            ) 
+            | 
+            (?: 
+                # The compatible operator requires at least two digits in the 
+                # release segment. 
+                (?<=~=)               # Only match for the compatible operator 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *) 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+            | 
+            (?: 
+                # All other operators only allow a sub set of what the 
+                # (non)equality operators do. Specifically they do not allow 
+                # local versions to be specified nor do they allow the prefix 
+                # matching wild cards. 
+                (?<!==|!=|~=)         # We have special cases for these 
+                                      # operators so we want to make sure they 
+                                      # don't match here. 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+        ) 
+        """ 
+    ) 
+ 
+    _regex = re.compile( 
+        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE) 
+ 
+    _operators = { 
+        "~=": "compatible", 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+        "===": "arbitrary", 
+    } 
+ 
+    @_require_version_compare 
+    def _compare_compatible(self, prospective, spec): 
+        # Compatible releases have an equivalent combination of >= and ==. That 
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to 
+        # implement this in terms of the other specifiers instead of 
+        # implementing it ourselves. The only thing we need to do is construct 
+        # the other specifiers. 
+ 
+        # We want everything but the last item in the version, but we want to 
+        # ignore post and dev releases and we want to treat the pre-release as 
+        # it's own separate segment. 
+        prefix = ".".join( 
+            list( 
+                itertools.takewhile( 
+                    lambda x: (not x.startswith("post") and not 
+                               x.startswith("dev")), 
+                    _version_split(spec), 
+                ) 
+            )[:-1] 
+        ) 
+ 
+        # Add the prefix notation to the end of our string 
+        prefix += ".*" 
+ 
+        return (self._get_operator(">=")(prospective, spec) and 
+                self._get_operator("==")(prospective, prefix)) 
+ 
+    @_require_version_compare 
+    def _compare_equal(self, prospective, spec): 
+        # We need special logic to handle prefix matching 
+        if spec.endswith(".*"): 
+            # In the case of prefix matching we want to ignore local segment. 
+            prospective = Version(prospective.public) 
+            # Split the spec out by dots, and pretend that there is an implicit 
+            # dot in between a release segment and a pre-release segment. 
+            spec = _version_split(spec[:-2])  # Remove the trailing .* 
+ 
+            # Split the prospective version out by dots, and pretend that there 
+            # is an implicit dot in between a release segment and a pre-release 
+            # segment. 
+            prospective = _version_split(str(prospective)) 
+ 
+            # Shorten the prospective version to be the same length as the spec 
+            # so that we can determine if the specifier is a prefix of the 
+            # prospective version or not. 
+            prospective = prospective[:len(spec)] 
+ 
+            # Pad out our two sides with zeros so that they both equal the same 
+            # length. 
+            spec, prospective = _pad_version(spec, prospective) 
+        else: 
+            # Convert our spec string into a Version 
+            spec = Version(spec) 
+ 
+            # If the specifier does not have a local segment, then we want to 
+            # act as if the prospective version also does not have a local 
+            # segment. 
+            if not spec.local: 
+                prospective = Version(prospective.public) 
+ 
+        return prospective == spec 
+ 
+    @_require_version_compare 
+    def _compare_not_equal(self, prospective, spec): 
+        return not self._compare_equal(prospective, spec) 
+ 
+    @_require_version_compare 
+    def _compare_less_than_equal(self, prospective, spec): 
+        return prospective <= Version(spec) 
+ 
+    @_require_version_compare 
+    def _compare_greater_than_equal(self, prospective, spec): 
+        return prospective >= Version(spec) 
+ 
+    @_require_version_compare 
+    def _compare_less_than(self, prospective, spec): 
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
+        spec = Version(spec) 
+ 
+        # Check to see if the prospective version is less than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective < spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a pre-release version, that we do not accept pre-release 
+        # versions for the version mentioned in the specifier (e.g. <3.1 should 
+        # not match 3.1.dev0, but should match 3.0.dev0). 
+        if not spec.is_prerelease and prospective.is_prerelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # less than the spec version *and* it's not a pre-release of the same 
+        # version in the spec. 
+        return True 
+ 
+    @_require_version_compare 
+    def _compare_greater_than(self, prospective, spec): 
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
+        spec = Version(spec) 
+ 
+        # Check to see if the prospective version is greater than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective > spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a post-release version, that we do not accept 
+        # post-release versions for the version mentioned in the specifier 
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). 
+        if not spec.is_postrelease and prospective.is_postrelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # Ensure that we do not allow a local version of the version mentioned 
+        # in the specifier, which is techincally greater than, to match. 
+        if prospective.local is not None: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # greater than the spec version *and* it's not a pre-release of the 
+        # same version in the spec. 
+        return True 
+ 
+    def _compare_arbitrary(self, prospective, spec): 
+        return str(prospective).lower() == str(spec).lower() 
+ 
+    @property 
+    def prereleases(self): 
+        # If there is an explicit prereleases set for this, then we'll just 
+        # blindly use that. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # Look at all of our specifiers and determine if they are inclusive 
+        # operators, and if they are if they are including an explicit 
+        # prerelease. 
+        operator, version = self._spec 
+        if operator in ["==", ">=", "<=", "~=", "==="]: 
+            # The == specifier can include a trailing .*, if it does we 
+            # want to remove before parsing. 
+            if operator == "==" and version.endswith(".*"): 
+                version = version[:-2] 
+ 
+            # Parse the version, and if it is a pre-release than this 
+            # specifier allows pre-releases. 
+            if parse(version).is_prerelease: 
+                return True 
+ 
+        return False 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        self._prereleases = value 
+ 
+ 
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") 
+ 
+ 
+def _version_split(version): 
+    result = [] 
+    for item in version.split("."): 
+        match = _prefix_regex.search(item) 
+        if match: 
+            result.extend(match.groups()) 
+        else: 
+            result.append(item) 
+    return result 
+ 
+ 
+def _pad_version(left, right): 
+    left_split, right_split = [], [] 
+ 
+    # Get the release segment of our versions 
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) 
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) 
+ 
+    # Get the rest of our versions 
+    left_split.append(left[len(left_split[0]):]) 
+    right_split.append(right[len(right_split[0]):]) 
+ 
+    # Insert our padding 
+    left_split.insert( 
+        1, 
+        ["0"] * max(0, len(right_split[0]) - len(left_split[0])), 
+    ) 
+    right_split.insert( 
+        1, 
+        ["0"] * max(0, len(left_split[0]) - len(right_split[0])), 
+    ) 
+ 
+    return ( 
+        list(itertools.chain(*left_split)), 
+        list(itertools.chain(*right_split)), 
+    ) 
+ 
+ 
+class SpecifierSet(BaseSpecifier): 
+ 
+    def __init__(self, specifiers="", prereleases=None): 
+        # Split on , to break each indidivual specifier into it's own item, and 
+        # strip each item to remove leading/trailing whitespace. 
+        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] 
+ 
+        # Parsed each individual specifier, attempting first to make it a 
+        # Specifier and falling back to a LegacySpecifier. 
+        parsed = set() 
+        for specifier in specifiers: 
+            try: 
+                parsed.add(Specifier(specifier)) 
+            except InvalidSpecifier: 
+                parsed.add(LegacySpecifier(specifier)) 
+ 
+        # Turn our parsed specifiers into a frozen set and save them for later. 
+        self._specs = frozenset(parsed) 
+ 
+        # Store our prereleases value so we can use it later to determine if 
+        # we accept prereleases or not. 
+        self._prereleases = prereleases 
+ 
+    def __repr__(self): 
+        pre = ( 
+            ", prereleases={0!r}".format(self.prereleases) 
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
+        return "<SpecifierSet({0!r}{1})>".format(str(self), pre) 
+ 
+    def __str__(self): 
+        return ",".join(sorted(str(s) for s in self._specs)) 
+ 
+    def __hash__(self): 
+        return hash(self._specs) 
+ 
+    def __and__(self, other): 
+        if isinstance(other, string_types): 
+            other = SpecifierSet(other) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        specifier = SpecifierSet() 
+        specifier._specs = frozenset(self._specs | other._specs) 
+ 
+        if self._prereleases is None and other._prereleases is not None: 
+            specifier._prereleases = other._prereleases 
+        elif self._prereleases is not None and other._prereleases is None: 
+            specifier._prereleases = self._prereleases 
+        elif self._prereleases == other._prereleases: 
+            specifier._prereleases = self._prereleases 
+        else: 
+            raise ValueError( 
+                "Cannot combine SpecifierSets with True and False prerelease " 
+                "overrides." 
+            ) 
+ 
+        return specifier 
+ 
+    def __eq__(self, other): 
+        if isinstance(other, string_types): 
+            other = SpecifierSet(other) 
+        elif isinstance(other, _IndividualSpecifier): 
+            other = SpecifierSet(str(other)) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        return self._specs == other._specs 
+ 
+    def __ne__(self, other): 
+        if isinstance(other, string_types): 
+            other = SpecifierSet(other) 
+        elif isinstance(other, _IndividualSpecifier): 
+            other = SpecifierSet(str(other)) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        return self._specs != other._specs 
+ 
+    def __len__(self): 
+        return len(self._specs) 
+ 
+    def __iter__(self): 
+        return iter(self._specs) 
+ 
+    @property 
+    def prereleases(self): 
+        # If we have been given an explicit prerelease modifier, then we'll 
+        # pass that through here. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # If we don't have any specifiers, and we don't have a forced value, 
+        # then we'll just return None since we don't know if this should have 
+        # pre-releases or not. 
+        if not self._specs: 
+            return None 
+ 
+        # Otherwise we'll see if any of the given specifiers accept 
+        # prereleases, if any of them do we'll return True, otherwise False. 
+        return any(s.prereleases for s in self._specs) 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        self._prereleases = value 
+ 
+    def __contains__(self, item): 
+        return self.contains(item) 
+ 
+    def contains(self, item, prereleases=None): 
+        # Ensure that our item is a Version or LegacyVersion instance. 
+        if not isinstance(item, (LegacyVersion, Version)): 
+            item = parse(item) 
+ 
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # We can determine if we're going to allow pre-releases by looking to 
+        # see if any of the underlying items supports them. If none of them do 
+        # and this item is a pre-release then we do not allow it and we can 
+        # short circuit that here. 
+        # Note: This means that 1.0.dev1 would not be contained in something 
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 
+        if not prereleases and item.is_prerelease: 
+            return False 
+ 
+        # We simply dispatch to the underlying specs here to make sure that the 
+        # given version is contained within all of them. 
+        # Note: This use of all() here means that an empty set of specifiers 
+        #       will always return True, this is an explicit design decision. 
+        return all( 
+            s.contains(item, prereleases=prereleases) 
+            for s in self._specs 
+        ) 
+ 
+    def filter(self, iterable, prereleases=None): 
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # If we have any specifiers, then we want to wrap our iterable in the 
+        # filter method for each one, this will act as a logical AND amongst 
+        # each specifier. 
+        if self._specs: 
+            for spec in self._specs: 
+                iterable = spec.filter(iterable, prereleases=bool(prereleases)) 
+            return iterable 
+        # If we do not have any specifiers, then we need to have a rough filter 
+        # which will filter out any pre-releases, unless there are no final 
+        # releases, and which will filter out LegacyVersion in general. 
+        else: 
+            filtered = [] 
+            found_prereleases = [] 
+ 
+            for item in iterable: 
+                # Ensure that we some kind of Version class for this item. 
+                if not isinstance(item, (LegacyVersion, Version)): 
+                    parsed_version = parse(item) 
+                else: 
+                    parsed_version = item 
+ 
+                # Filter out any item which is parsed as a LegacyVersion 
+                if isinstance(parsed_version, LegacyVersion): 
+                    continue 
+ 
+                # Store any item which is a pre-release for later unless we've 
+                # already found a final version or we are accepting prereleases 
+                if parsed_version.is_prerelease and not prereleases: 
+                    if not filtered: 
+                        found_prereleases.append(item) 
+                else: 
+                    filtered.append(item) 
+ 
+            # If we've found no items except for pre-releases, then we'll go 
+            # ahead and use the pre-releases 
+            if not filtered and found_prereleases and prereleases is None: 
+                return found_prereleases 
+ 
+            return filtered 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/utils.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/utils.py
index 942387cef5..58087311c9 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/utils.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/utils.py
@@ -1,14 +1,14 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import re
-
-
-_canonicalize_regex = re.compile(r"[-_.]+")
-
-
-def canonicalize_name(name):
-    # This is taken from PEP 503.
-    return _canonicalize_regex.sub("-", name).lower()
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import re 
+ 
+ 
+_canonicalize_regex = re.compile(r"[-_.]+") 
+ 
+ 
+def canonicalize_name(name): 
+    # This is taken from PEP 503. 
+    return _canonicalize_regex.sub("-", name).lower() 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/version.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/version.py
index 83b5ee8c5e..ae99cba1f6 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/version.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/packaging/version.py
@@ -1,393 +1,393 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import collections
-import itertools
-import re
-
-from ._structures import Infinity
-
-
-__all__ = [
-    "parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"
-]
-
-
-_Version = collections.namedtuple(
-    "_Version",
-    ["epoch", "release", "dev", "pre", "post", "local"],
-)
-
-
-def parse(version):
-    """
-    Parse the given version string and return either a :class:`Version` object
-    or a :class:`LegacyVersion` object depending on if the given version is
-    a valid PEP 440 version or a legacy version.
-    """
-    try:
-        return Version(version)
-    except InvalidVersion:
-        return LegacyVersion(version)
-
-
-class InvalidVersion(ValueError):
-    """
-    An invalid version was found, users should refer to PEP 440.
-    """
-
-
-class _BaseVersion(object):
-
-    def __hash__(self):
-        return hash(self._key)
-
-    def __lt__(self, other):
-        return self._compare(other, lambda s, o: s < o)
-
-    def __le__(self, other):
-        return self._compare(other, lambda s, o: s <= o)
-
-    def __eq__(self, other):
-        return self._compare(other, lambda s, o: s == o)
-
-    def __ge__(self, other):
-        return self._compare(other, lambda s, o: s >= o)
-
-    def __gt__(self, other):
-        return self._compare(other, lambda s, o: s > o)
-
-    def __ne__(self, other):
-        return self._compare(other, lambda s, o: s != o)
-
-    def _compare(self, other, method):
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return method(self._key, other._key)
-
-
-class LegacyVersion(_BaseVersion):
-
-    def __init__(self, version):
-        self._version = str(version)
-        self._key = _legacy_cmpkey(self._version)
-
-    def __str__(self):
-        return self._version
-
-    def __repr__(self):
-        return "<LegacyVersion({0})>".format(repr(str(self)))
-
-    @property
-    def public(self):
-        return self._version
-
-    @property
-    def base_version(self):
-        return self._version
-
-    @property
-    def local(self):
-        return None
-
-    @property
-    def is_prerelease(self):
-        return False
-
-    @property
-    def is_postrelease(self):
-        return False
-
-
-_legacy_version_component_re = re.compile(
-    r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE,
-)
-
-_legacy_version_replacement_map = {
-    "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@",
-}
-
-
-def _parse_version_parts(s):
-    for part in _legacy_version_component_re.split(s):
-        part = _legacy_version_replacement_map.get(part, part)
-
-        if not part or part == ".":
-            continue
-
-        if part[:1] in "0123456789":
-            # pad for numeric comparison
-            yield part.zfill(8)
-        else:
-            yield "*" + part
-
-    # ensure that alpha/beta/candidate are before final
-    yield "*final"
-
-
-def _legacy_cmpkey(version):
-    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
-    # greater than or equal to 0. This will effectively put the LegacyVersion,
-    # which uses the defacto standard originally implemented by setuptools,
-    # as before all PEP 440 versions.
-    epoch = -1
-
-    # This scheme is taken from pkg_resources.parse_version setuptools prior to
-    # it's adoption of the packaging library.
-    parts = []
-    for part in _parse_version_parts(version.lower()):
-        if part.startswith("*"):
-            # remove "-" before a prerelease tag
-            if part < "*final":
-                while parts and parts[-1] == "*final-":
-                    parts.pop()
-
-            # remove trailing zeros from each series of numeric parts
-            while parts and parts[-1] == "00000000":
-                parts.pop()
-
-        parts.append(part)
-    parts = tuple(parts)
-
-    return epoch, parts
-
-# Deliberately not anchored to the start and end of the string, to make it
-# easier for 3rd party code to reuse
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-
-class Version(_BaseVersion):
-
-    _regex = re.compile(
-        r"^\s*" + VERSION_PATTERN + r"\s*$",
-        re.VERBOSE | re.IGNORECASE,
-    )
-
-    def __init__(self, version):
-        # Validate the version and parse it into pieces
-        match = self._regex.search(version)
-        if not match:
-            raise InvalidVersion("Invalid version: '{0}'".format(version))
-
-        # Store the parsed out pieces of the version
-        self._version = _Version(
-            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
-            release=tuple(int(i) for i in match.group("release").split(".")),
-            pre=_parse_letter_version(
-                match.group("pre_l"),
-                match.group("pre_n"),
-            ),
-            post=_parse_letter_version(
-                match.group("post_l"),
-                match.group("post_n1") or match.group("post_n2"),
-            ),
-            dev=_parse_letter_version(
-                match.group("dev_l"),
-                match.group("dev_n"),
-            ),
-            local=_parse_local_version(match.group("local")),
-        )
-
-        # Generate a key which will be used for sorting
-        self._key = _cmpkey(
-            self._version.epoch,
-            self._version.release,
-            self._version.pre,
-            self._version.post,
-            self._version.dev,
-            self._version.local,
-        )
-
-    def __repr__(self):
-        return "<Version({0})>".format(repr(str(self)))
-
-    def __str__(self):
-        parts = []
-
-        # Epoch
-        if self._version.epoch != 0:
-            parts.append("{0}!".format(self._version.epoch))
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self._version.release))
-
-        # Pre-release
-        if self._version.pre is not None:
-            parts.append("".join(str(x) for x in self._version.pre))
-
-        # Post-release
-        if self._version.post is not None:
-            parts.append(".post{0}".format(self._version.post[1]))
-
-        # Development release
-        if self._version.dev is not None:
-            parts.append(".dev{0}".format(self._version.dev[1]))
-
-        # Local version segment
-        if self._version.local is not None:
-            parts.append(
-                "+{0}".format(".".join(str(x) for x in self._version.local))
-            )
-
-        return "".join(parts)
-
-    @property
-    def public(self):
-        return str(self).split("+", 1)[0]
-
-    @property
-    def base_version(self):
-        parts = []
-
-        # Epoch
-        if self._version.epoch != 0:
-            parts.append("{0}!".format(self._version.epoch))
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self._version.release))
-
-        return "".join(parts)
-
-    @property
-    def local(self):
-        version_string = str(self)
-        if "+" in version_string:
-            return version_string.split("+", 1)[1]
-
-    @property
-    def is_prerelease(self):
-        return bool(self._version.dev or self._version.pre)
-
-    @property
-    def is_postrelease(self):
-        return bool(self._version.post)
-
-
-def _parse_letter_version(letter, number):
-    if letter:
-        # We consider there to be an implicit 0 in a pre-release if there is
-        # not a numeral associated with it.
-        if number is None:
-            number = 0
-
-        # We normalize any letters to their lower case form
-        letter = letter.lower()
-
-        # We consider some words to be alternate spellings of other words and
-        # in those cases we want to normalize the spellings to our preferred
-        # spelling.
-        if letter == "alpha":
-            letter = "a"
-        elif letter == "beta":
-            letter = "b"
-        elif letter in ["c", "pre", "preview"]:
-            letter = "rc"
-        elif letter in ["rev", "r"]:
-            letter = "post"
-
-        return letter, int(number)
-    if not letter and number:
-        # We assume if we are given a number, but we are not given a letter
-        # then this is using the implicit post release syntax (e.g. 1.0-1)
-        letter = "post"
-
-        return letter, int(number)
-
-
-_local_version_seperators = re.compile(r"[\._-]")
-
-
-def _parse_local_version(local):
-    """
-    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
-    """
-    if local is not None:
-        return tuple(
-            part.lower() if not part.isdigit() else int(part)
-            for part in _local_version_seperators.split(local)
-        )
-
-
-def _cmpkey(epoch, release, pre, post, dev, local):
-    # When we compare a release version, we want to compare it with all of the
-    # trailing zeros removed. So we'll use a reverse the list, drop all the now
-    # leading zeros until we come to something non zero, then take the rest
-    # re-reverse it back into the correct order and make it a tuple and use
-    # that for our sorting key.
-    release = tuple(
-        reversed(list(
-            itertools.dropwhile(
-                lambda x: x == 0,
-                reversed(release),
-            )
-        ))
-    )
-
-    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
-    # We'll do this by abusing the pre segment, but we _only_ want to do this
-    # if there is not a pre or a post segment. If we have one of those then
-    # the normal sorting rules will handle this case correctly.
-    if pre is None and post is None and dev is not None:
-        pre = -Infinity
-    # Versions without a pre-release (except as noted above) should sort after
-    # those with one.
-    elif pre is None:
-        pre = Infinity
-
-    # Versions without a post segment should sort before those with one.
-    if post is None:
-        post = -Infinity
-
-    # Versions without a development segment should sort after those with one.
-    if dev is None:
-        dev = Infinity
-
-    if local is None:
-        # Versions without a local segment should sort before those with one.
-        local = -Infinity
-    else:
-        # Versions with a local segment need that segment parsed to implement
-        # the sorting rules in PEP440.
-        # - Alpha numeric segments sort before numeric segments
-        # - Alpha numeric segments sort lexicographically
-        # - Numeric segments sort numerically
-        # - Shorter versions sort before longer versions when the prefixes
-        #   match exactly
-        local = tuple(
-            (i, "") if isinstance(i, int) else (-Infinity, i)
-            for i in local
-        )
-
-    return epoch, release, pre, post, dev, local
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import collections 
+import itertools 
+import re 
+ 
+from ._structures import Infinity 
+ 
+ 
+__all__ = [ 
+    "parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN" 
+] 
+ 
+ 
+_Version = collections.namedtuple( 
+    "_Version", 
+    ["epoch", "release", "dev", "pre", "post", "local"], 
+) 
+ 
+ 
+def parse(version): 
+    """ 
+    Parse the given version string and return either a :class:`Version` object 
+    or a :class:`LegacyVersion` object depending on if the given version is 
+    a valid PEP 440 version or a legacy version. 
+    """ 
+    try: 
+        return Version(version) 
+    except InvalidVersion: 
+        return LegacyVersion(version) 
+ 
+ 
+class InvalidVersion(ValueError): 
+    """ 
+    An invalid version was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
+class _BaseVersion(object): 
+ 
+    def __hash__(self): 
+        return hash(self._key) 
+ 
+    def __lt__(self, other): 
+        return self._compare(other, lambda s, o: s < o) 
+ 
+    def __le__(self, other): 
+        return self._compare(other, lambda s, o: s <= o) 
+ 
+    def __eq__(self, other): 
+        return self._compare(other, lambda s, o: s == o) 
+ 
+    def __ge__(self, other): 
+        return self._compare(other, lambda s, o: s >= o) 
+ 
+    def __gt__(self, other): 
+        return self._compare(other, lambda s, o: s > o) 
+ 
+    def __ne__(self, other): 
+        return self._compare(other, lambda s, o: s != o) 
+ 
+    def _compare(self, other, method): 
+        if not isinstance(other, _BaseVersion): 
+            return NotImplemented 
+ 
+        return method(self._key, other._key) 
+ 
+ 
+class LegacyVersion(_BaseVersion): 
+ 
+    def __init__(self, version): 
+        self._version = str(version) 
+        self._key = _legacy_cmpkey(self._version) 
+ 
+    def __str__(self): 
+        return self._version 
+ 
+    def __repr__(self): 
+        return "<LegacyVersion({0})>".format(repr(str(self))) 
+ 
+    @property 
+    def public(self): 
+        return self._version 
+ 
+    @property 
+    def base_version(self): 
+        return self._version 
+ 
+    @property 
+    def local(self): 
+        return None 
+ 
+    @property 
+    def is_prerelease(self): 
+        return False 
+ 
+    @property 
+    def is_postrelease(self): 
+        return False 
+ 
+ 
+_legacy_version_component_re = re.compile( 
+    r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE, 
+) 
+ 
+_legacy_version_replacement_map = { 
+    "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@", 
+} 
+ 
+ 
+def _parse_version_parts(s): 
+    for part in _legacy_version_component_re.split(s): 
+        part = _legacy_version_replacement_map.get(part, part) 
+ 
+        if not part or part == ".": 
+            continue 
+ 
+        if part[:1] in "0123456789": 
+            # pad for numeric comparison 
+            yield part.zfill(8) 
+        else: 
+            yield "*" + part 
+ 
+    # ensure that alpha/beta/candidate are before final 
+    yield "*final" 
+ 
+ 
+def _legacy_cmpkey(version): 
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch 
+    # greater than or equal to 0. This will effectively put the LegacyVersion, 
+    # which uses the defacto standard originally implemented by setuptools, 
+    # as before all PEP 440 versions. 
+    epoch = -1 
+ 
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to 
+    # it's adoption of the packaging library. 
+    parts = [] 
+    for part in _parse_version_parts(version.lower()): 
+        if part.startswith("*"): 
+            # remove "-" before a prerelease tag 
+            if part < "*final": 
+                while parts and parts[-1] == "*final-": 
+                    parts.pop() 
+ 
+            # remove trailing zeros from each series of numeric parts 
+            while parts and parts[-1] == "00000000": 
+                parts.pop() 
+ 
+        parts.append(part) 
+    parts = tuple(parts) 
+ 
+    return epoch, parts 
+ 
+# Deliberately not anchored to the start and end of the string, to make it 
+# easier for 3rd party code to reuse 
+VERSION_PATTERN = r""" 
+    v? 
+    (?: 
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch 
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment 
+        (?P<pre>                                          # pre-release 
+            [-_\.]? 
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview)) 
+            [-_\.]? 
+            (?P<pre_n>[0-9]+)? 
+        )? 
+        (?P<post>                                         # post release 
+            (?:-(?P<post_n1>[0-9]+)) 
+            | 
+            (?: 
+                [-_\.]? 
+                (?P<post_l>post|rev|r) 
+                [-_\.]? 
+                (?P<post_n2>[0-9]+)? 
+            ) 
+        )? 
+        (?P<dev>                                          # dev release 
+            [-_\.]? 
+            (?P<dev_l>dev) 
+            [-_\.]? 
+            (?P<dev_n>[0-9]+)? 
+        )? 
+    ) 
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version 
+""" 
+ 
+ 
+class Version(_BaseVersion): 
+ 
+    _regex = re.compile( 
+        r"^\s*" + VERSION_PATTERN + r"\s*$", 
+        re.VERBOSE | re.IGNORECASE, 
+    ) 
+ 
+    def __init__(self, version): 
+        # Validate the version and parse it into pieces 
+        match = self._regex.search(version) 
+        if not match: 
+            raise InvalidVersion("Invalid version: '{0}'".format(version)) 
+ 
+        # Store the parsed out pieces of the version 
+        self._version = _Version( 
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0, 
+            release=tuple(int(i) for i in match.group("release").split(".")), 
+            pre=_parse_letter_version( 
+                match.group("pre_l"), 
+                match.group("pre_n"), 
+            ), 
+            post=_parse_letter_version( 
+                match.group("post_l"), 
+                match.group("post_n1") or match.group("post_n2"), 
+            ), 
+            dev=_parse_letter_version( 
+                match.group("dev_l"), 
+                match.group("dev_n"), 
+            ), 
+            local=_parse_local_version(match.group("local")), 
+        ) 
+ 
+        # Generate a key which will be used for sorting 
+        self._key = _cmpkey( 
+            self._version.epoch, 
+            self._version.release, 
+            self._version.pre, 
+            self._version.post, 
+            self._version.dev, 
+            self._version.local, 
+        ) 
+ 
+    def __repr__(self): 
+        return "<Version({0})>".format(repr(str(self))) 
+ 
+    def __str__(self): 
+        parts = [] 
+ 
+        # Epoch 
+        if self._version.epoch != 0: 
+            parts.append("{0}!".format(self._version.epoch)) 
+ 
+        # Release segment 
+        parts.append(".".join(str(x) for x in self._version.release)) 
+ 
+        # Pre-release 
+        if self._version.pre is not None: 
+            parts.append("".join(str(x) for x in self._version.pre)) 
+ 
+        # Post-release 
+        if self._version.post is not None: 
+            parts.append(".post{0}".format(self._version.post[1])) 
+ 
+        # Development release 
+        if self._version.dev is not None: 
+            parts.append(".dev{0}".format(self._version.dev[1])) 
+ 
+        # Local version segment 
+        if self._version.local is not None: 
+            parts.append( 
+                "+{0}".format(".".join(str(x) for x in self._version.local)) 
+            ) 
+ 
+        return "".join(parts) 
+ 
+    @property 
+    def public(self): 
+        return str(self).split("+", 1)[0] 
+ 
+    @property 
+    def base_version(self): 
+        parts = [] 
+ 
+        # Epoch 
+        if self._version.epoch != 0: 
+            parts.append("{0}!".format(self._version.epoch)) 
+ 
+        # Release segment 
+        parts.append(".".join(str(x) for x in self._version.release)) 
+ 
+        return "".join(parts) 
+ 
+    @property 
+    def local(self): 
+        version_string = str(self) 
+        if "+" in version_string: 
+            return version_string.split("+", 1)[1] 
+ 
+    @property 
+    def is_prerelease(self): 
+        return bool(self._version.dev or self._version.pre) 
+ 
+    @property 
+    def is_postrelease(self): 
+        return bool(self._version.post) 
+ 
+ 
+def _parse_letter_version(letter, number): 
+    if letter: 
+        # We consider there to be an implicit 0 in a pre-release if there is 
+        # not a numeral associated with it. 
+        if number is None: 
+            number = 0 
+ 
+        # We normalize any letters to their lower case form 
+        letter = letter.lower() 
+ 
+        # We consider some words to be alternate spellings of other words and 
+        # in those cases we want to normalize the spellings to our preferred 
+        # spelling. 
+        if letter == "alpha": 
+            letter = "a" 
+        elif letter == "beta": 
+            letter = "b" 
+        elif letter in ["c", "pre", "preview"]: 
+            letter = "rc" 
+        elif letter in ["rev", "r"]: 
+            letter = "post" 
+ 
+        return letter, int(number) 
+    if not letter and number: 
+        # We assume if we are given a number, but we are not given a letter 
+        # then this is using the implicit post release syntax (e.g. 1.0-1) 
+        letter = "post" 
+ 
+        return letter, int(number) 
+ 
+ 
+_local_version_seperators = re.compile(r"[\._-]") 
+ 
+ 
+def _parse_local_version(local): 
+    """ 
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). 
+    """ 
+    if local is not None: 
+        return tuple( 
+            part.lower() if not part.isdigit() else int(part) 
+            for part in _local_version_seperators.split(local) 
+        ) 
+ 
+ 
+def _cmpkey(epoch, release, pre, post, dev, local): 
+    # When we compare a release version, we want to compare it with all of the 
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now 
+    # leading zeros until we come to something non zero, then take the rest 
+    # re-reverse it back into the correct order and make it a tuple and use 
+    # that for our sorting key. 
+    release = tuple( 
+        reversed(list( 
+            itertools.dropwhile( 
+                lambda x: x == 0, 
+                reversed(release), 
+            ) 
+        )) 
+    ) 
+ 
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0. 
+    # We'll do this by abusing the pre segment, but we _only_ want to do this 
+    # if there is not a pre or a post segment. If we have one of those then 
+    # the normal sorting rules will handle this case correctly. 
+    if pre is None and post is None and dev is not None: 
+        pre = -Infinity 
+    # Versions without a pre-release (except as noted above) should sort after 
+    # those with one. 
+    elif pre is None: 
+        pre = Infinity 
+ 
+    # Versions without a post segment should sort before those with one. 
+    if post is None: 
+        post = -Infinity 
+ 
+    # Versions without a development segment should sort after those with one. 
+    if dev is None: 
+        dev = Infinity 
+ 
+    if local is None: 
+        # Versions without a local segment should sort before those with one. 
+        local = -Infinity 
+    else: 
+        # Versions with a local segment need that segment parsed to implement 
+        # the sorting rules in PEP440. 
+        # - Alpha numeric segments sort before numeric segments 
+        # - Alpha numeric segments sort lexicographically 
+        # - Numeric segments sort numerically 
+        # - Shorter versions sort before longer versions when the prefixes 
+        #   match exactly 
+        local = tuple( 
+            (i, "") if isinstance(i, int) else (-Infinity, i) 
+            for i in local 
+        ) 
+ 
+    return epoch, release, pre, post, dev, local 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/pyparsing.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/pyparsing.py
index cf75e1e5fc..b4a0aa3221 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/pyparsing.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/pyparsing.py
@@ -1,5742 +1,5742 @@
-# module pyparsing.py

-#

-# Copyright (c) 2003-2018  Paul T. McGuire

-#

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

-#

-

-__doc__ = \

-"""

-pyparsing module - Classes and methods to define and execute parsing grammars

-=============================================================================

-

-The pyparsing module is an alternative approach to creating and executing simple grammars,

-vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you

-don't need to learn a new syntax for defining grammars or matching expressions - the parsing module

-provides a library of classes that you use to construct the grammar directly in Python.

-

-Here is a program to parse "Hello, World!" (or any greeting of the form 

-C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements 

-(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to

-L{Literal} expressions)::

-

-    from pyparsing import Word, alphas

-

-    # define grammar of a greeting

-    greet = Word(alphas) + "," + Word(alphas) + "!"

-

-    hello = "Hello, World!"

-    print (hello, "->", greet.parseString(hello))

-

-The program outputs the following::

-

-    Hello, World! -> ['Hello', ',', 'World', '!']

-

-The Python representation of the grammar is quite readable, owing to the self-explanatory

-class names, and the use of '+', '|' and '^' operators.

-

-The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an

-object with named attributes.

-

-The pyparsing module handles some of the problems that are typically vexing when writing text parsers:

- - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)

- - quoted strings

- - embedded comments

-

-

-Getting Started -

------------------

-Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing

-classes inherit from. Use the docstrings for examples of how to:

- - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes

- - construct character word-group expressions using the L{Word} class

- - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes

- - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones

- - associate names with your parsed results using L{ParserElement.setResultsName}

- - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}

- - find more useful common expressions in the L{pyparsing_common} namespace class

-"""

-

-__version__ = "2.2.1"

-__versionTime__ = "18 Sep 2018 00:49 UTC"

-__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"

-

-import string

-from weakref import ref as wkref

-import copy

-import sys

-import warnings

-import re

-import sre_constants

-import collections

-import pprint

-import traceback

-import types

-from datetime import datetime

-

-try:

-    from _thread import RLock

-except ImportError:

-    from threading import RLock

-

-try:

-    # Python 3

-    from collections.abc import Iterable

-    from collections.abc import MutableMapping

-except ImportError:

-    # Python 2.7

-    from collections import Iterable

-    from collections import MutableMapping

-

-try:

-    from collections import OrderedDict as _OrderedDict

-except ImportError:

-    try:

-        from ordereddict import OrderedDict as _OrderedDict

-    except ImportError:

-        _OrderedDict = None

-

-#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )

-

-__all__ = [

-'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',

-'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',

-'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',

-'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',

-'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',

-'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 

-'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',

-'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',

-'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',

-'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',

-'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',

-'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',

-'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',

-'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 

-'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',

-'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',

-'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',

-'CloseMatch', 'tokenMap', 'pyparsing_common',

-]

-

-system_version = tuple(sys.version_info)[:3]

-PY_3 = system_version[0] == 3

-if PY_3:

-    _MAX_INT = sys.maxsize

-    basestring = str

-    unichr = chr

-    _ustr = str

-

-    # build list of single arg builtins, that can be used as parse actions

-    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]

-

-else:

-    _MAX_INT = sys.maxint

-    range = xrange

-

-    def _ustr(obj):

-        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries

-           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It

-           then < returns the unicode object | encodes it with the default encoding | ... >.

-        """

-        if isinstance(obj,unicode):

-            return obj

-

-        try:

-            # If this works, then _ustr(obj) has the same behaviour as str(obj), so

-            # it won't break any existing code.

-            return str(obj)

-

-        except UnicodeEncodeError:

-            # Else encode it

-            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')

-            xmlcharref = Regex(r'&#\d+;')

-            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])

-            return xmlcharref.transformString(ret)

-

-    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions

-    singleArgBuiltins = []

-    import __builtin__

-    for fname in "sum len sorted reversed list tuple set any all min max".split():

-        try:

-            singleArgBuiltins.append(getattr(__builtin__,fname))

-        except AttributeError:

-            continue

-            

-_generatorType = type((y for y in range(1)))

- 

-def _xml_escape(data):

-    """Escape &, <, >, ", ', etc. in a string of data."""

-

-    # ampersand must be replaced first

-    from_symbols = '&><"\''

-    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())

-    for from_,to_ in zip(from_symbols, to_symbols):

-        data = data.replace(from_, to_)

-    return data

-

-class _Constants(object):

-    pass

-

-alphas     = string.ascii_uppercase + string.ascii_lowercase

-nums       = "0123456789"

-hexnums    = nums + "ABCDEFabcdef"

-alphanums  = alphas + nums

-_bslash    = chr(92)

-printables = "".join(c for c in string.printable if c not in string.whitespace)

-

-class ParseBaseException(Exception):

-    """base exception class for all parsing runtime exceptions"""

-    # Performance tuning: we construct a *lot* of these, so keep this

-    # constructor as small and fast as possible

-    def __init__( self, pstr, loc=0, msg=None, elem=None ):

-        self.loc = loc

-        if msg is None:

-            self.msg = pstr

-            self.pstr = ""

-        else:

-            self.msg = msg

-            self.pstr = pstr

-        self.parserElement = elem

-        self.args = (pstr, loc, msg)

-

-    @classmethod

-    def _from_exception(cls, pe):

-        """

-        internal factory method to simplify creating one type of ParseException 

-        from another - avoids having __init__ signature conflicts among subclasses

-        """

-        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)

-

-    def __getattr__( self, aname ):

-        """supported attributes by name are:

-            - lineno - returns the line number of the exception text

-            - col - returns the column number of the exception text

-            - line - returns the line containing the exception text

-        """

-        if( aname == "lineno" ):

-            return lineno( self.loc, self.pstr )

-        elif( aname in ("col", "column") ):

-            return col( self.loc, self.pstr )

-        elif( aname == "line" ):

-            return line( self.loc, self.pstr )

-        else:

-            raise AttributeError(aname)

-

-    def __str__( self ):

-        return "%s (at char %d), (line:%d, col:%d)" % \

-                ( self.msg, self.loc, self.lineno, self.column )

-    def __repr__( self ):

-        return _ustr(self)

-    def markInputline( self, markerString = ">!<" ):

-        """Extracts the exception line from the input string, and marks

-           the location of the exception with a special symbol.

-        """

-        line_str = self.line

-        line_column = self.column - 1

-        if markerString:

-            line_str = "".join((line_str[:line_column],

-                                markerString, line_str[line_column:]))

-        return line_str.strip()

-    def __dir__(self):

-        return "lineno col line".split() + dir(type(self))

-

-class ParseException(ParseBaseException):

-    """

-    Exception thrown when parse expressions don't match class;

-    supported attributes by name are:

-     - lineno - returns the line number of the exception text

-     - col - returns the column number of the exception text

-     - line - returns the line containing the exception text

-        

-    Example::

-        try:

-            Word(nums).setName("integer").parseString("ABC")

-        except ParseException as pe:

-            print(pe)

-            print("column: {}".format(pe.col))

-            

-    prints::

-       Expected integer (at char 0), (line:1, col:1)

-        column: 1

-    """

-    pass

-

-class ParseFatalException(ParseBaseException):

-    """user-throwable exception thrown when inconsistent parse content

-       is found; stops all parsing immediately"""

-    pass

-

-class ParseSyntaxException(ParseFatalException):

-    """just like L{ParseFatalException}, but thrown internally when an

-       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop 

-       immediately because an unbacktrackable syntax error has been found"""

-    pass

-

-#~ class ReparseException(ParseBaseException):

-    #~ """Experimental class - parse actions can raise this exception to cause

-       #~ pyparsing to reparse the input string:

-        #~ - with a modified input string, and/or

-        #~ - with a modified start location

-       #~ Set the values of the ReparseException in the constructor, and raise the

-       #~ exception in a parse action to cause pyparsing to use the new string/location.

-       #~ Setting the values as None causes no change to be made.

-       #~ """

-    #~ def __init_( self, newstring, restartLoc ):

-        #~ self.newParseText = newstring

-        #~ self.reparseLoc = restartLoc

-

-class RecursiveGrammarException(Exception):

-    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""

-    def __init__( self, parseElementList ):

-        self.parseElementTrace = parseElementList

-

-    def __str__( self ):

-        return "RecursiveGrammarException: %s" % self.parseElementTrace

-

-class _ParseResultsWithOffset(object):

-    def __init__(self,p1,p2):

-        self.tup = (p1,p2)

-    def __getitem__(self,i):

-        return self.tup[i]

-    def __repr__(self):

-        return repr(self.tup[0])

-    def setOffset(self,i):

-        self.tup = (self.tup[0],i)

-

-class ParseResults(object):

-    """

-    Structured parse results, to provide multiple means of access to the parsed data:

-       - as a list (C{len(results)})

-       - by list index (C{results[0], results[1]}, etc.)

-       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName})

-

-    Example::

-        integer = Word(nums)

-        date_str = (integer.setResultsName("year") + '/' 

-                        + integer.setResultsName("month") + '/' 

-                        + integer.setResultsName("day"))

-        # equivalent form:

-        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-

-        # parseString returns a ParseResults object

-        result = date_str.parseString("1999/12/31")

-

-        def test(s, fn=repr):

-            print("%s -> %s" % (s, fn(eval(s))))

-        test("list(result)")

-        test("result[0]")

-        test("result['month']")

-        test("result.day")

-        test("'month' in result")

-        test("'minutes' in result")

-        test("result.dump()", str)

-    prints::

-        list(result) -> ['1999', '/', '12', '/', '31']

-        result[0] -> '1999'

-        result['month'] -> '12'

-        result.day -> '31'

-        'month' in result -> True

-        'minutes' in result -> False

-        result.dump() -> ['1999', '/', '12', '/', '31']

-        - day: 31

-        - month: 12

-        - year: 1999

-    """

-    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):

-        if isinstance(toklist, cls):

-            return toklist

-        retobj = object.__new__(cls)

-        retobj.__doinit = True

-        return retobj

-

-    # Performance tuning: we construct a *lot* of these, so keep this

-    # constructor as small and fast as possible

-    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):

-        if self.__doinit:

-            self.__doinit = False

-            self.__name = None

-            self.__parent = None

-            self.__accumNames = {}

-            self.__asList = asList

-            self.__modal = modal

-            if toklist is None:

-                toklist = []

-            if isinstance(toklist, list):

-                self.__toklist = toklist[:]

-            elif isinstance(toklist, _generatorType):

-                self.__toklist = list(toklist)

-            else:

-                self.__toklist = [toklist]

-            self.__tokdict = dict()

-

-        if name is not None and name:

-            if not modal:

-                self.__accumNames[name] = 0

-            if isinstance(name,int):

-                name = _ustr(name) # will always return a str, but use _ustr for consistency

-            self.__name = name

-            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):

-                if isinstance(toklist,basestring):

-                    toklist = [ toklist ]

-                if asList:

-                    if isinstance(toklist,ParseResults):

-                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)

-                    else:

-                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)

-                    self[name].__name = name

-                else:

-                    try:

-                        self[name] = toklist[0]

-                    except (KeyError,TypeError,IndexError):

-                        self[name] = toklist

-

-    def __getitem__( self, i ):

-        if isinstance( i, (int,slice) ):

-            return self.__toklist[i]

-        else:

-            if i not in self.__accumNames:

-                return self.__tokdict[i][-1][0]

-            else:

-                return ParseResults([ v[0] for v in self.__tokdict[i] ])

-

-    def __setitem__( self, k, v, isinstance=isinstance ):

-        if isinstance(v,_ParseResultsWithOffset):

-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]

-            sub = v[0]

-        elif isinstance(k,(int,slice)):

-            self.__toklist[k] = v

-            sub = v

-        else:

-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]

-            sub = v

-        if isinstance(sub,ParseResults):

-            sub.__parent = wkref(self)

-

-    def __delitem__( self, i ):

-        if isinstance(i,(int,slice)):

-            mylen = len( self.__toklist )

-            del self.__toklist[i]

-

-            # convert int to slice

-            if isinstance(i, int):

-                if i < 0:

-                    i += mylen

-                i = slice(i, i+1)

-            # get removed indices

-            removed = list(range(*i.indices(mylen)))

-            removed.reverse()

-            # fixup indices in token dictionary

-            for name,occurrences in self.__tokdict.items():

-                for j in removed:

-                    for k, (value, position) in enumerate(occurrences):

-                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))

-        else:

-            del self.__tokdict[i]

-

-    def __contains__( self, k ):

-        return k in self.__tokdict

-

-    def __len__( self ): return len( self.__toklist )

-    def __bool__(self): return ( not not self.__toklist )

-    __nonzero__ = __bool__

-    def __iter__( self ): return iter( self.__toklist )

-    def __reversed__( self ): return iter( self.__toklist[::-1] )

-    def _iterkeys( self ):

-        if hasattr(self.__tokdict, "iterkeys"):

-            return self.__tokdict.iterkeys()

-        else:

-            return iter(self.__tokdict)

-

-    def _itervalues( self ):

-        return (self[k] for k in self._iterkeys())

-            

-    def _iteritems( self ):

-        return ((k, self[k]) for k in self._iterkeys())

-

-    if PY_3:

-        keys = _iterkeys       

-        """Returns an iterator of all named result keys (Python 3.x only)."""

-

-        values = _itervalues

-        """Returns an iterator of all named result values (Python 3.x only)."""

-

-        items = _iteritems

-        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""

-

-    else:

-        iterkeys = _iterkeys

-        """Returns an iterator of all named result keys (Python 2.x only)."""

-

-        itervalues = _itervalues

-        """Returns an iterator of all named result values (Python 2.x only)."""

-

-        iteritems = _iteritems

-        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""

-

-        def keys( self ):

-            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""

-            return list(self.iterkeys())

-

-        def values( self ):

-            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""

-            return list(self.itervalues())

-                

-        def items( self ):

-            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""

-            return list(self.iteritems())

-

-    def haskeys( self ):

-        """Since keys() returns an iterator, this method is helpful in bypassing

-           code that looks for the existence of any defined results names."""

-        return bool(self.__tokdict)

-        

-    def pop( self, *args, **kwargs):

-        """

-        Removes and returns item at specified index (default=C{last}).

-        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no

-        argument or an integer argument, it will use C{list} semantics

-        and pop tokens from the list of parsed tokens. If passed a 

-        non-integer argument (most likely a string), it will use C{dict}

-        semantics and pop the corresponding value from any defined 

-        results names. A second default return value argument is 

-        supported, just as in C{dict.pop()}.

-

-        Example::

-            def remove_first(tokens):

-                tokens.pop(0)

-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

-            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']

-

-            label = Word(alphas)

-            patt = label("LABEL") + OneOrMore(Word(nums))

-            print(patt.parseString("AAB 123 321").dump())

-

-            # Use pop() in a parse action to remove named result (note that corresponding value is not

-            # removed from list form of results)

-            def remove_LABEL(tokens):

-                tokens.pop("LABEL")

-                return tokens

-            patt.addParseAction(remove_LABEL)

-            print(patt.parseString("AAB 123 321").dump())

-        prints::

-            ['AAB', '123', '321']

-            - LABEL: AAB

-

-            ['AAB', '123', '321']

-        """

-        if not args:

-            args = [-1]

-        for k,v in kwargs.items():

-            if k == 'default':

-                args = (args[0], v)

-            else:

-                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)

-        if (isinstance(args[0], int) or 

-                        len(args) == 1 or 

-                        args[0] in self):

-            index = args[0]

-            ret = self[index]

-            del self[index]

-            return ret

-        else:

-            defaultvalue = args[1]

-            return defaultvalue

-

-    def get(self, key, defaultValue=None):

-        """

-        Returns named result matching the given key, or if there is no

-        such name, then returns the given C{defaultValue} or C{None} if no

-        C{defaultValue} is specified.

-

-        Similar to C{dict.get()}.

-        

-        Example::

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

-

-            result = date_str.parseString("1999/12/31")

-            print(result.get("year")) # -> '1999'

-            print(result.get("hour", "not specified")) # -> 'not specified'

-            print(result.get("hour")) # -> None

-        """

-        if key in self:

-            return self[key]

-        else:

-            return defaultValue

-

-    def insert( self, index, insStr ):

-        """

-        Inserts new element at location index in the list of parsed tokens.

-        

-        Similar to C{list.insert()}.

-

-        Example::

-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

-

-            # use a parse action to insert the parse location in the front of the parsed results

-            def insert_locn(locn, tokens):

-                tokens.insert(0, locn)

-            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']

-        """

-        self.__toklist.insert(index, insStr)

-        # fixup indices in token dictionary

-        for name,occurrences in self.__tokdict.items():

-            for k, (value, position) in enumerate(occurrences):

-                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))

-

-    def append( self, item ):

-        """

-        Add single element to end of ParseResults list of elements.

-

-        Example::

-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

-            

-            # use a parse action to compute the sum of the parsed integers, and add it to the end

-            def append_sum(tokens):

-                tokens.append(sum(map(int, tokens)))

-            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]

-        """

-        self.__toklist.append(item)

-

-    def extend( self, itemseq ):

-        """

-        Add sequence of elements to end of ParseResults list of elements.

-

-        Example::

-            patt = OneOrMore(Word(alphas))

-            

-            # use a parse action to append the reverse of the matched strings, to make a palindrome

-            def make_palindrome(tokens):

-                tokens.extend(reversed([t[::-1] for t in tokens]))

-                return ''.join(tokens)

-            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'

-        """

-        if isinstance(itemseq, ParseResults):

-            self += itemseq

-        else:

-            self.__toklist.extend(itemseq)

-

-    def clear( self ):

-        """

-        Clear all elements and results names.

-        """

-        del self.__toklist[:]

-        self.__tokdict.clear()

-

-    def __getattr__( self, name ):

-        try:

-            return self[name]

-        except KeyError:

-            return ""

-            

-        if name in self.__tokdict:

-            if name not in self.__accumNames:

-                return self.__tokdict[name][-1][0]

-            else:

-                return ParseResults([ v[0] for v in self.__tokdict[name] ])

-        else:

-            return ""

-

-    def __add__( self, other ):

-        ret = self.copy()

-        ret += other

-        return ret

-

-    def __iadd__( self, other ):

-        if other.__tokdict:

-            offset = len(self.__toklist)

-            addoffset = lambda a: offset if a<0 else a+offset

-            otheritems = other.__tokdict.items()

-            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )

-                                for (k,vlist) in otheritems for v in vlist]

-            for k,v in otherdictitems:

-                self[k] = v

-                if isinstance(v[0],ParseResults):

-                    v[0].__parent = wkref(self)

-            

-        self.__toklist += other.__toklist

-        self.__accumNames.update( other.__accumNames )

-        return self

-

-    def __radd__(self, other):

-        if isinstance(other,int) and other == 0:

-            # useful for merging many ParseResults using sum() builtin

-            return self.copy()

-        else:

-            # this may raise a TypeError - so be it

-            return other + self

-        

-    def __repr__( self ):

-        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )

-

-    def __str__( self ):

-        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'

-

-    def _asStringList( self, sep='' ):

-        out = []

-        for item in self.__toklist:

-            if out and sep:

-                out.append(sep)

-            if isinstance( item, ParseResults ):

-                out += item._asStringList()

-            else:

-                out.append( _ustr(item) )

-        return out

-

-    def asList( self ):

-        """

-        Returns the parse results as a nested list of matching tokens, all converted to strings.

-

-        Example::

-            patt = OneOrMore(Word(alphas))

-            result = patt.parseString("sldkj lsdkj sldkj")

-            # even though the result prints in string-like form, it is actually a pyparsing ParseResults

-            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']

-            

-            # Use asList() to create an actual list

-            result_list = result.asList()

-            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']

-        """

-        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]

-

-    def asDict( self ):

-        """

-        Returns the named parse results as a nested dictionary.

-

-        Example::

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-            

-            result = date_str.parseString('12/31/1999')

-            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})

-            

-            result_dict = result.asDict()

-            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}

-

-            # even though a ParseResults supports dict-like access, sometime you just need to have a dict

-            import json

-            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable

-            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}

-        """

-        if PY_3:

-            item_fn = self.items

-        else:

-            item_fn = self.iteritems

-            

-        def toItem(obj):

-            if isinstance(obj, ParseResults):

-                if obj.haskeys():

-                    return obj.asDict()

-                else:

-                    return [toItem(v) for v in obj]

-            else:

-                return obj

-                

-        return dict((k,toItem(v)) for k,v in item_fn())

-

-    def copy( self ):

-        """

-        Returns a new copy of a C{ParseResults} object.

-        """

-        ret = ParseResults( self.__toklist )

-        ret.__tokdict = self.__tokdict.copy()

-        ret.__parent = self.__parent

-        ret.__accumNames.update( self.__accumNames )

-        ret.__name = self.__name

-        return ret

-

-    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):

-        """

-        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.

-        """

-        nl = "\n"

-        out = []

-        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()

-                                                            for v in vlist)

-        nextLevelIndent = indent + "  "

-

-        # collapse out indents if formatting is not desired

-        if not formatted:

-            indent = ""

-            nextLevelIndent = ""

-            nl = ""

-

-        selfTag = None

-        if doctag is not None:

-            selfTag = doctag

-        else:

-            if self.__name:

-                selfTag = self.__name

-

-        if not selfTag:

-            if namedItemsOnly:

-                return ""

-            else:

-                selfTag = "ITEM"

-

-        out += [ nl, indent, "<", selfTag, ">" ]

-

-        for i,res in enumerate(self.__toklist):

-            if isinstance(res,ParseResults):

-                if i in namedItems:

-                    out += [ res.asXML(namedItems[i],

-                                        namedItemsOnly and doctag is None,

-                                        nextLevelIndent,

-                                        formatted)]

-                else:

-                    out += [ res.asXML(None,

-                                        namedItemsOnly and doctag is None,

-                                        nextLevelIndent,

-                                        formatted)]

-            else:

-                # individual token, see if there is a name for it

-                resTag = None

-                if i in namedItems:

-                    resTag = namedItems[i]

-                if not resTag:

-                    if namedItemsOnly:

-                        continue

-                    else:

-                        resTag = "ITEM"

-                xmlBodyText = _xml_escape(_ustr(res))

-                out += [ nl, nextLevelIndent, "<", resTag, ">",

-                                                xmlBodyText,

-                                                "</", resTag, ">" ]

-

-        out += [ nl, indent, "</", selfTag, ">" ]

-        return "".join(out)

-

-    def __lookup(self,sub):

-        for k,vlist in self.__tokdict.items():

-            for v,loc in vlist:

-                if sub is v:

-                    return k

-        return None

-

-    def getName(self):

-        r"""

-        Returns the results name for this token expression. Useful when several 

-        different expressions might match at a particular location.

-

-        Example::

-            integer = Word(nums)

-            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")

-            house_number_expr = Suppress('#') + Word(nums, alphanums)

-            user_data = (Group(house_number_expr)("house_number") 

-                        | Group(ssn_expr)("ssn")

-                        | Group(integer)("age"))

-            user_info = OneOrMore(user_data)

-            

-            result = user_info.parseString("22 111-22-3333 #221B")

-            for item in result:

-                print(item.getName(), ':', item[0])

-        prints::

-            age : 22

-            ssn : 111-22-3333

-            house_number : 221B

-        """

-        if self.__name:

-            return self.__name

-        elif self.__parent:

-            par = self.__parent()

-            if par:

-                return par.__lookup(self)

-            else:

-                return None

-        elif (len(self) == 1 and

-               len(self.__tokdict) == 1 and

-               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):

-            return next(iter(self.__tokdict.keys()))

-        else:

-            return None

-

-    def dump(self, indent='', depth=0, full=True):

-        """

-        Diagnostic method for listing out the contents of a C{ParseResults}.

-        Accepts an optional C{indent} argument so that this string can be embedded

-        in a nested display of other data.

-

-        Example::

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-            

-            result = date_str.parseString('12/31/1999')

-            print(result.dump())

-        prints::

-            ['12', '/', '31', '/', '1999']

-            - day: 1999

-            - month: 31

-            - year: 12

-        """

-        out = []

-        NL = '\n'

-        out.append( indent+_ustr(self.asList()) )

-        if full:

-            if self.haskeys():

-                items = sorted((str(k), v) for k,v in self.items())

-                for k,v in items:

-                    if out:

-                        out.append(NL)

-                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )

-                    if isinstance(v,ParseResults):

-                        if v:

-                            out.append( v.dump(indent,depth+1) )

-                        else:

-                            out.append(_ustr(v))

-                    else:

-                        out.append(repr(v))

-            elif any(isinstance(vv,ParseResults) for vv in self):

-                v = self

-                for i,vv in enumerate(v):

-                    if isinstance(vv,ParseResults):

-                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))

-                    else:

-                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))

-            

-        return "".join(out)

-

-    def pprint(self, *args, **kwargs):

-        """

-        Pretty-printer for parsed results as a list, using the C{pprint} module.

-        Accepts additional positional or keyword args as defined for the 

-        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})

-

-        Example::

-            ident = Word(alphas, alphanums)

-            num = Word(nums)

-            func = Forward()

-            term = ident | num | Group('(' + func + ')')

-            func <<= ident + Group(Optional(delimitedList(term)))

-            result = func.parseString("fna a,b,(fnb c,d,200),100")

-            result.pprint(width=40)

-        prints::

-            ['fna',

-             ['a',

-              'b',

-              ['(', 'fnb', ['c', 'd', '200'], ')'],

-              '100']]

-        """

-        pprint.pprint(self.asList(), *args, **kwargs)

-

-    # add support for pickle protocol

-    def __getstate__(self):

-        return ( self.__toklist,

-                 ( self.__tokdict.copy(),

-                   self.__parent is not None and self.__parent() or None,

-                   self.__accumNames,

-                   self.__name ) )

-

-    def __setstate__(self,state):

-        self.__toklist = state[0]

-        (self.__tokdict,

-         par,

-         inAccumNames,

-         self.__name) = state[1]

-        self.__accumNames = {}

-        self.__accumNames.update(inAccumNames)

-        if par is not None:

-            self.__parent = wkref(par)

-        else:

-            self.__parent = None

-

-    def __getnewargs__(self):

-        return self.__toklist, self.__name, self.__asList, self.__modal

-

-    def __dir__(self):

-        return (dir(type(self)) + list(self.keys()))

-

-MutableMapping.register(ParseResults)

-

-def col (loc,strg):

-    """Returns current column within a string, counting newlines as line separators.

-   The first column is number 1.

-

-   Note: the default parsing behavior is to expand tabs in the input string

-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information

-   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a

-   consistent view of the parsed string, the parse location, and line and column

-   positions within the parsed string.

-   """

-    s = strg

-    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc)

-

-def lineno(loc,strg):

-    """Returns current line number within a string, counting newlines as line separators.

-   The first line is number 1.

-

-   Note: the default parsing behavior is to expand tabs in the input string

-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information

-   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a

-   consistent view of the parsed string, the parse location, and line and column

-   positions within the parsed string.

-   """

-    return strg.count("\n",0,loc) + 1

-

-def line( loc, strg ):

-    """Returns the line of text containing loc within a string, counting newlines as line separators.

-       """

-    lastCR = strg.rfind("\n", 0, loc)

-    nextCR = strg.find("\n", loc)

-    if nextCR >= 0:

-        return strg[lastCR+1:nextCR]

-    else:

-        return strg[lastCR+1:]

-

-def _defaultStartDebugAction( instring, loc, expr ):

-    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))

-

-def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):

-    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))

-

-def _defaultExceptionDebugAction( instring, loc, expr, exc ):

-    print ("Exception raised:" + _ustr(exc))

-

-def nullDebugAction(*args):

-    """'Do-nothing' debug action, to suppress debugging output during parsing."""

-    pass

-

-# Only works on Python 3.x - nonlocal is toxic to Python 2 installs

-#~ 'decorator to trim function calls to match the arity of the target'

-#~ def _trim_arity(func, maxargs=3):

-    #~ if func in singleArgBuiltins:

-        #~ return lambda s,l,t: func(t)

-    #~ limit = 0

-    #~ foundArity = False

-    #~ def wrapper(*args):

-        #~ nonlocal limit,foundArity

-        #~ while 1:

-            #~ try:

-                #~ ret = func(*args[limit:])

-                #~ foundArity = True

-                #~ return ret

-            #~ except TypeError:

-                #~ if limit == maxargs or foundArity:

-                    #~ raise

-                #~ limit += 1

-                #~ continue

-    #~ return wrapper

-

-# this version is Python 2.x-3.x cross-compatible

-'decorator to trim function calls to match the arity of the target'

-def _trim_arity(func, maxargs=2):

-    if func in singleArgBuiltins:

-        return lambda s,l,t: func(t)

-    limit = [0]

-    foundArity = [False]

-    

-    # traceback return data structure changed in Py3.5 - normalize back to plain tuples

-    if system_version[:2] >= (3,5):

-        def extract_stack(limit=0):

-            # special handling for Python 3.5.0 - extra deep call stack by 1

-            offset = -3 if system_version == (3,5,0) else -2

-            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]

-            return [frame_summary[:2]]

-        def extract_tb(tb, limit=0):

-            frames = traceback.extract_tb(tb, limit=limit)

-            frame_summary = frames[-1]

-            return [frame_summary[:2]]

-    else:

-        extract_stack = traceback.extract_stack

-        extract_tb = traceback.extract_tb

-    

-    # synthesize what would be returned by traceback.extract_stack at the call to 

-    # user's parse action 'func', so that we don't incur call penalty at parse time

-    

-    LINE_DIFF = 6

-    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 

-    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!

-    this_line = extract_stack(limit=2)[-1]

-    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)

-

-    def wrapper(*args):

-        while 1:

-            try:

-                ret = func(*args[limit[0]:])

-                foundArity[0] = True

-                return ret

-            except TypeError:

-                # re-raise TypeErrors if they did not come from our arity testing

-                if foundArity[0]:

-                    raise

-                else:

-                    try:

-                        tb = sys.exc_info()[-1]

-                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:

-                            raise

-                    finally:

-                        del tb

-

-                if limit[0] <= maxargs:

-                    limit[0] += 1

-                    continue

-                raise

-

-    # copy func name to wrapper for sensible debug output

-    func_name = "<parse action>"

-    try:

-        func_name = getattr(func, '__name__', 

-                            getattr(func, '__class__').__name__)

-    except Exception:

-        func_name = str(func)

-    wrapper.__name__ = func_name

-

-    return wrapper

-

-class ParserElement(object):

-    """Abstract base level parser element class."""

-    DEFAULT_WHITE_CHARS = " \n\t\r"

-    verbose_stacktrace = False

-

-    @staticmethod

-    def setDefaultWhitespaceChars( chars ):

-        r"""

-        Overrides the default whitespace chars

-

-        Example::

-            # default whitespace chars are space, <TAB> and newline

-            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']

-            

-            # change to just treat newline as significant

-            ParserElement.setDefaultWhitespaceChars(" \t")

-            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']

-        """

-        ParserElement.DEFAULT_WHITE_CHARS = chars

-

-    @staticmethod

-    def inlineLiteralsUsing(cls):

-        """

-        Set class to be used for inclusion of string literals into a parser.

-        

-        Example::

-            # default literal class used is Literal

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

-

-            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']

-

-

-            # change to Suppress

-            ParserElement.inlineLiteralsUsing(Suppress)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

-

-            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']

-        """

-        ParserElement._literalStringClass = cls

-

-    def __init__( self, savelist=False ):

-        self.parseAction = list()

-        self.failAction = None

-        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall

-        self.strRepr = None

-        self.resultsName = None

-        self.saveAsList = savelist

-        self.skipWhitespace = True

-        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS

-        self.copyDefaultWhiteChars = True

-        self.mayReturnEmpty = False # used when checking for left-recursion

-        self.keepTabs = False

-        self.ignoreExprs = list()

-        self.debug = False

-        self.streamlined = False

-        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index

-        self.errmsg = ""

-        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)

-        self.debugActions = ( None, None, None ) #custom debug actions

-        self.re = None

-        self.callPreparse = True # used to avoid redundant calls to preParse

-        self.callDuringTry = False

-

-    def copy( self ):

-        """

-        Make a copy of this C{ParserElement}.  Useful for defining different parse actions

-        for the same parsing pattern, using copies of the original parse element.

-        

-        Example::

-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))

-            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")

-            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")

-            

-            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))

-        prints::

-            [5120, 100, 655360, 268435456]

-        Equivalent form of C{expr.copy()} is just C{expr()}::

-            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")

-        """

-        cpy = copy.copy( self )

-        cpy.parseAction = self.parseAction[:]

-        cpy.ignoreExprs = self.ignoreExprs[:]

-        if self.copyDefaultWhiteChars:

-            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS

-        return cpy

-

-    def setName( self, name ):

-        """

-        Define name for this expression, makes debugging and exception messages clearer.

-        

-        Example::

-            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)

-            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)

-        """

-        self.name = name

-        self.errmsg = "Expected " + self.name

-        if hasattr(self,"exception"):

-            self.exception.msg = self.errmsg

-        return self

-

-    def setResultsName( self, name, listAllMatches=False ):

-        """

-        Define name for referencing matching tokens as a nested attribute

-        of the returned parse results.

-        NOTE: this returns a *copy* of the original C{ParserElement} object;

-        this is so that the client can define a basic element, such as an

-        integer, and reference it in multiple places with different names.

-

-        You can also set results names using the abbreviated syntax,

-        C{expr("name")} in place of C{expr.setResultsName("name")} - 

-        see L{I{__call__}<__call__>}.

-

-        Example::

-            date_str = (integer.setResultsName("year") + '/' 

-                        + integer.setResultsName("month") + '/' 

-                        + integer.setResultsName("day"))

-

-            # equivalent form:

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-        """

-        newself = self.copy()

-        if name.endswith("*"):

-            name = name[:-1]

-            listAllMatches=True

-        newself.resultsName = name

-        newself.modalResults = not listAllMatches

-        return newself

-

-    def setBreak(self,breakFlag = True):

-        """Method to invoke the Python pdb debugger when this element is

-           about to be parsed. Set C{breakFlag} to True to enable, False to

-           disable.

-        """

-        if breakFlag:

-            _parseMethod = self._parse

-            def breaker(instring, loc, doActions=True, callPreParse=True):

-                import pdb

-                pdb.set_trace()

-                return _parseMethod( instring, loc, doActions, callPreParse )

-            breaker._originalParseMethod = _parseMethod

-            self._parse = breaker

-        else:

-            if hasattr(self._parse,"_originalParseMethod"):

-                self._parse = self._parse._originalParseMethod

-        return self

-

-    def setParseAction( self, *fns, **kwargs ):

-        """

-        Define one or more actions to perform when successfully matching parse element definition.

-        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},

-        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:

-         - s   = the original string being parsed (see note below)

-         - loc = the location of the matching substring

-         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object

-        If the functions in fns modify the tokens, they can return them as the return

-        value from fn, and the modified list of tokens will replace the original.

-        Otherwise, fn does not need to return any value.

-

-        Optional keyword arguments:

-         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing

-

-        Note: the default parsing behavior is to expand tabs in the input string

-        before starting the parsing process.  See L{I{parseString}<parseString>} for more information

-        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a

-        consistent view of the parsed string, the parse location, and line and column

-        positions within the parsed string.

-        

-        Example::

-            integer = Word(nums)

-            date_str = integer + '/' + integer + '/' + integer

-

-            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']

-

-            # use parse action to convert to ints at parse time

-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))

-            date_str = integer + '/' + integer + '/' + integer

-

-            # note that integer fields are now ints, not strings

-            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]

-        """

-        self.parseAction = list(map(_trim_arity, list(fns)))

-        self.callDuringTry = kwargs.get("callDuringTry", False)

-        return self

-

-    def addParseAction( self, *fns, **kwargs ):

-        """

-        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.

-        

-        See examples in L{I{copy}<copy>}.

-        """

-        self.parseAction += list(map(_trim_arity, list(fns)))

-        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)

-        return self

-

-    def addCondition(self, *fns, **kwargs):

-        """Add a boolean predicate function to expression's list of parse actions. See 

-        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction}, 

-        functions passed to C{addCondition} need to return boolean success/fail of the condition.

-

-        Optional keyword arguments:

-         - message = define a custom message to be used in the raised exception

-         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException

-         

-        Example::

-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))

-            year_int = integer.copy()

-            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")

-            date_str = year_int + '/' + integer + '/' + integer

-

-            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)

-        """

-        msg = kwargs.get("message", "failed user-defined condition")

-        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException

-        for fn in fns:

-            def pa(s,l,t):

-                if not bool(_trim_arity(fn)(s,l,t)):

-                    raise exc_type(s,l,msg)

-            self.parseAction.append(pa)

-        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)

-        return self

-

-    def setFailAction( self, fn ):

-        """Define action to perform if parsing fails at this expression.

-           Fail acton fn is a callable function that takes the arguments

-           C{fn(s,loc,expr,err)} where:

-            - s = string being parsed

-            - loc = location where expression match was attempted and failed

-            - expr = the parse expression that failed

-            - err = the exception thrown

-           The function returns no value.  It may throw C{L{ParseFatalException}}

-           if it is desired to stop parsing immediately."""

-        self.failAction = fn

-        return self

-

-    def _skipIgnorables( self, instring, loc ):

-        exprsFound = True

-        while exprsFound:

-            exprsFound = False

-            for e in self.ignoreExprs:

-                try:

-                    while 1:

-                        loc,dummy = e._parse( instring, loc )

-                        exprsFound = True

-                except ParseException:

-                    pass

-        return loc

-

-    def preParse( self, instring, loc ):

-        if self.ignoreExprs:

-            loc = self._skipIgnorables( instring, loc )

-

-        if self.skipWhitespace:

-            wt = self.whiteChars

-            instrlen = len(instring)

-            while loc < instrlen and instring[loc] in wt:

-                loc += 1

-

-        return loc

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        return loc, []

-

-    def postParse( self, instring, loc, tokenlist ):

-        return tokenlist

-

-    #~ @profile

-    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):

-        debugging = ( self.debug ) #and doActions )

-

-        if debugging or self.failAction:

-            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))

-            if (self.debugActions[0] ):

-                self.debugActions[0]( instring, loc, self )

-            if callPreParse and self.callPreparse:

-                preloc = self.preParse( instring, loc )

-            else:

-                preloc = loc

-            tokensStart = preloc

-            try:

-                try:

-                    loc,tokens = self.parseImpl( instring, preloc, doActions )

-                except IndexError:

-                    raise ParseException( instring, len(instring), self.errmsg, self )

-            except ParseBaseException as err:

-                #~ print ("Exception raised:", err)

-                if self.debugActions[2]:

-                    self.debugActions[2]( instring, tokensStart, self, err )

-                if self.failAction:

-                    self.failAction( instring, tokensStart, self, err )

-                raise

-        else:

-            if callPreParse and self.callPreparse:

-                preloc = self.preParse( instring, loc )

-            else:

-                preloc = loc

-            tokensStart = preloc

-            if self.mayIndexError or preloc >= len(instring):

-                try:

-                    loc,tokens = self.parseImpl( instring, preloc, doActions )

-                except IndexError:

-                    raise ParseException( instring, len(instring), self.errmsg, self )

-            else:

-                loc,tokens = self.parseImpl( instring, preloc, doActions )

-

-        tokens = self.postParse( instring, loc, tokens )

-

-        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )

-        if self.parseAction and (doActions or self.callDuringTry):

-            if debugging:

-                try:

-                    for fn in self.parseAction:

-                        tokens = fn( instring, tokensStart, retTokens )

-                        if tokens is not None:

-                            retTokens = ParseResults( tokens,

-                                                      self.resultsName,

-                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),

-                                                      modal=self.modalResults )

-                except ParseBaseException as err:

-                    #~ print "Exception raised in user parse action:", err

-                    if (self.debugActions[2] ):

-                        self.debugActions[2]( instring, tokensStart, self, err )

-                    raise

-            else:

-                for fn in self.parseAction:

-                    tokens = fn( instring, tokensStart, retTokens )

-                    if tokens is not None:

-                        retTokens = ParseResults( tokens,

-                                                  self.resultsName,

-                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),

-                                                  modal=self.modalResults )

-        if debugging:

-            #~ print ("Matched",self,"->",retTokens.asList())

-            if (self.debugActions[1] ):

-                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )

-

-        return loc, retTokens

-

-    def tryParse( self, instring, loc ):

-        try:

-            return self._parse( instring, loc, doActions=False )[0]

-        except ParseFatalException:

-            raise ParseException( instring, loc, self.errmsg, self)

-    

-    def canParseNext(self, instring, loc):

-        try:

-            self.tryParse(instring, loc)

-        except (ParseException, IndexError):

-            return False

-        else:

-            return True

-

-    class _UnboundedCache(object):

-        def __init__(self):

-            cache = {}

-            self.not_in_cache = not_in_cache = object()

-

-            def get(self, key):

-                return cache.get(key, not_in_cache)

-

-            def set(self, key, value):

-                cache[key] = value

-

-            def clear(self):

-                cache.clear()

-                

-            def cache_len(self):

-                return len(cache)

-

-            self.get = types.MethodType(get, self)

-            self.set = types.MethodType(set, self)

-            self.clear = types.MethodType(clear, self)

-            self.__len__ = types.MethodType(cache_len, self)

-

-    if _OrderedDict is not None:

-        class _FifoCache(object):

-            def __init__(self, size):

-                self.not_in_cache = not_in_cache = object()

-

-                cache = _OrderedDict()

-

-                def get(self, key):

-                    return cache.get(key, not_in_cache)

-

-                def set(self, key, value):

-                    cache[key] = value

-                    while len(cache) > size:

-                        try:

-                            cache.popitem(False)

-                        except KeyError:

-                            pass

-

-                def clear(self):

-                    cache.clear()

-

-                def cache_len(self):

-                    return len(cache)

-

-                self.get = types.MethodType(get, self)

-                self.set = types.MethodType(set, self)

-                self.clear = types.MethodType(clear, self)

-                self.__len__ = types.MethodType(cache_len, self)

-

-    else:

-        class _FifoCache(object):

-            def __init__(self, size):

-                self.not_in_cache = not_in_cache = object()

-

-                cache = {}

-                key_fifo = collections.deque([], size)

-

-                def get(self, key):

-                    return cache.get(key, not_in_cache)

-

-                def set(self, key, value):

-                    cache[key] = value

-                    while len(key_fifo) > size:

-                        cache.pop(key_fifo.popleft(), None)

-                    key_fifo.append(key)

-

-                def clear(self):

-                    cache.clear()

-                    key_fifo.clear()

-

-                def cache_len(self):

-                    return len(cache)

-

-                self.get = types.MethodType(get, self)

-                self.set = types.MethodType(set, self)

-                self.clear = types.MethodType(clear, self)

-                self.__len__ = types.MethodType(cache_len, self)

-

-    # argument cache for optimizing repeated calls when backtracking through recursive expressions

-    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail

-    packrat_cache_lock = RLock()

-    packrat_cache_stats = [0, 0]

-

-    # this method gets repeatedly called during backtracking with the same arguments -

-    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression

-    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):

-        HIT, MISS = 0, 1

-        lookup = (self, instring, loc, callPreParse, doActions)

-        with ParserElement.packrat_cache_lock:

-            cache = ParserElement.packrat_cache

-            value = cache.get(lookup)

-            if value is cache.not_in_cache:

-                ParserElement.packrat_cache_stats[MISS] += 1

-                try:

-                    value = self._parseNoCache(instring, loc, doActions, callPreParse)

-                except ParseBaseException as pe:

-                    # cache a copy of the exception, without the traceback

-                    cache.set(lookup, pe.__class__(*pe.args))

-                    raise

-                else:

-                    cache.set(lookup, (value[0], value[1].copy()))

-                    return value

-            else:

-                ParserElement.packrat_cache_stats[HIT] += 1

-                if isinstance(value, Exception):

-                    raise value

-                return (value[0], value[1].copy())

-

-    _parse = _parseNoCache

-

-    @staticmethod

-    def resetCache():

-        ParserElement.packrat_cache.clear()

-        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)

-

-    _packratEnabled = False

-    @staticmethod

-    def enablePackrat(cache_size_limit=128):

-        """Enables "packrat" parsing, which adds memoizing to the parsing logic.

-           Repeated parse attempts at the same string location (which happens

-           often in many complex grammars) can immediately return a cached value,

-           instead of re-executing parsing/validating code.  Memoizing is done of

-           both valid results and parsing exceptions.

-           

-           Parameters:

-            - cache_size_limit - (default=C{128}) - if an integer value is provided

-              will limit the size of the packrat cache; if None is passed, then

-              the cache size will be unbounded; if 0 is passed, the cache will

-              be effectively disabled.

-            

-           This speedup may break existing programs that use parse actions that

-           have side-effects.  For this reason, packrat parsing is disabled when

-           you first import pyparsing.  To activate the packrat feature, your

-           program must call the class method C{ParserElement.enablePackrat()}.  If

-           your program uses C{psyco} to "compile as you go", you must call

-           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,

-           Python will crash.  For best results, call C{enablePackrat()} immediately

-           after importing pyparsing.

-           

-           Example::

-               import pyparsing

-               pyparsing.ParserElement.enablePackrat()

-        """

-        if not ParserElement._packratEnabled:

-            ParserElement._packratEnabled = True

-            if cache_size_limit is None:

-                ParserElement.packrat_cache = ParserElement._UnboundedCache()

-            else:

-                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)

-            ParserElement._parse = ParserElement._parseCache

-

-    def parseString( self, instring, parseAll=False ):

-        """

-        Execute the parse expression with the given string.

-        This is the main interface to the client code, once the complete

-        expression has been built.

-

-        If you want the grammar to require that the entire input string be

-        successfully parsed, then set C{parseAll} to True (equivalent to ending

-        the grammar with C{L{StringEnd()}}).

-

-        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,

-        in order to report proper column numbers in parse actions.

-        If the input string contains tabs and

-        the grammar uses parse actions that use the C{loc} argument to index into the

-        string being parsed, you can ensure you have a consistent view of the input

-        string by:

-         - calling C{parseWithTabs} on your grammar before calling C{parseString}

-           (see L{I{parseWithTabs}<parseWithTabs>})

-         - define your parse action using the full C{(s,loc,toks)} signature, and

-           reference the input string using the parse action's C{s} argument

-         - explictly expand the tabs in your input string before calling

-           C{parseString}

-        

-        Example::

-            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']

-            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text

-        """

-        ParserElement.resetCache()

-        if not self.streamlined:

-            self.streamline()

-            #~ self.saveAsList = True

-        for e in self.ignoreExprs:

-            e.streamline()

-        if not self.keepTabs:

-            instring = instring.expandtabs()

-        try:

-            loc, tokens = self._parse( instring, 0 )

-            if parseAll:

-                loc = self.preParse( instring, loc )

-                se = Empty() + StringEnd()

-                se._parse( instring, loc )

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-        else:

-            return tokens

-

-    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):

-        """

-        Scan the input string for expression matches.  Each match will return the

-        matching tokens, start location, and end location.  May be called with optional

-        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If

-        C{overlap} is specified, then overlapping matches will be reported.

-

-        Note that the start and end locations are reported relative to the string

-        being parsed.  See L{I{parseString}<parseString>} for more information on parsing

-        strings with embedded tabs.

-

-        Example::

-            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"

-            print(source)

-            for tokens,start,end in Word(alphas).scanString(source):

-                print(' '*start + '^'*(end-start))

-                print(' '*start + tokens[0])

-        

-        prints::

-        

-            sldjf123lsdjjkf345sldkjf879lkjsfd987

-            ^^^^^

-            sldjf

-                    ^^^^^^^

-                    lsdjjkf

-                              ^^^^^^

-                              sldkjf

-                                       ^^^^^^

-                                       lkjsfd

-        """

-        if not self.streamlined:

-            self.streamline()

-        for e in self.ignoreExprs:

-            e.streamline()

-

-        if not self.keepTabs:

-            instring = _ustr(instring).expandtabs()

-        instrlen = len(instring)

-        loc = 0

-        preparseFn = self.preParse

-        parseFn = self._parse

-        ParserElement.resetCache()

-        matches = 0

-        try:

-            while loc <= instrlen and matches < maxMatches:

-                try:

-                    preloc = preparseFn( instring, loc )

-                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )

-                except ParseException:

-                    loc = preloc+1

-                else:

-                    if nextLoc > loc:

-                        matches += 1

-                        yield tokens, preloc, nextLoc

-                        if overlap:

-                            nextloc = preparseFn( instring, loc )

-                            if nextloc > loc:

-                                loc = nextLoc

-                            else:

-                                loc += 1

-                        else:

-                            loc = nextLoc

-                    else:

-                        loc = preloc+1

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def transformString( self, instring ):

-        """

-        Extension to C{L{scanString}}, to modify matching text with modified tokens that may

-        be returned from a parse action.  To use C{transformString}, define a grammar and

-        attach a parse action to it that modifies the returned token list.

-        Invoking C{transformString()} on a target string will then scan for matches,

-        and replace the matched text patterns according to the logic in the parse

-        action.  C{transformString()} returns the resulting transformed string.

-        

-        Example::

-            wd = Word(alphas)

-            wd.setParseAction(lambda toks: toks[0].title())

-            

-            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))

-        Prints::

-            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.

-        """

-        out = []

-        lastE = 0

-        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to

-        # keep string locs straight between transformString and scanString

-        self.keepTabs = True

-        try:

-            for t,s,e in self.scanString( instring ):

-                out.append( instring[lastE:s] )

-                if t:

-                    if isinstance(t,ParseResults):

-                        out += t.asList()

-                    elif isinstance(t,list):

-                        out += t

-                    else:

-                        out.append(t)

-                lastE = e

-            out.append(instring[lastE:])

-            out = [o for o in out if o]

-            return "".join(map(_ustr,_flatten(out)))

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def searchString( self, instring, maxMatches=_MAX_INT ):

-        """

-        Another extension to C{L{scanString}}, simplifying the access to the tokens found

-        to match the given parse expression.  May be called with optional

-        C{maxMatches} argument, to clip searching after 'n' matches are found.

-        

-        Example::

-            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters

-            cap_word = Word(alphas.upper(), alphas.lower())

-            

-            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))

-

-            # the sum() builtin can be used to merge results into a single ParseResults object

-            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))

-        prints::

-            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]

-            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']

-        """

-        try:

-            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):

-        """

-        Generator method to split a string using the given expression as a separator.

-        May be called with optional C{maxsplit} argument, to limit the number of splits;

-        and the optional C{includeSeparators} argument (default=C{False}), if the separating

-        matching text should be included in the split results.

-        

-        Example::        

-            punc = oneOf(list(".,;:/-!?"))

-            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))

-        prints::

-            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']

-        """

-        splits = 0

-        last = 0

-        for t,s,e in self.scanString(instring, maxMatches=maxsplit):

-            yield instring[last:s]

-            if includeSeparators:

-                yield t[0]

-            last = e

-        yield instring[last:]

-

-    def __add__(self, other ):

-        """

-        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement

-        converts them to L{Literal}s by default.

-        

-        Example::

-            greet = Word(alphas) + "," + Word(alphas) + "!"

-            hello = "Hello, World!"

-            print (hello, "->", greet.parseString(hello))

-        Prints::

-            Hello, World! -> ['Hello', ',', 'World', '!']

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return And( [ self, other ] )

-

-    def __radd__(self, other ):

-        """

-        Implementation of + operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other + self

-

-    def __sub__(self, other):

-        """

-        Implementation of - operator, returns C{L{And}} with error stop

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return self + And._ErrorStop() + other

-

-    def __rsub__(self, other ):

-        """

-        Implementation of - operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other - self

-

-    def __mul__(self,other):

-        """

-        Implementation of * operator, allows use of C{expr * 3} in place of

-        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer

-        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples

-        may also include C{None} as in:

-         - C{expr*(n,None)} or C{expr*(n,)} is equivalent

-              to C{expr*n + L{ZeroOrMore}(expr)}

-              (read as "at least n instances of C{expr}")

-         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}

-              (read as "0 to n instances of C{expr}")

-         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}

-         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}

-

-        Note that C{expr*(None,n)} does not raise an exception if

-        more than n exprs exist in the input stream; that is,

-        C{expr*(None,n)} does not enforce a maximum number of expr

-        occurrences.  If this behavior is desired, then write

-        C{expr*(None,n) + ~expr}

-        """

-        if isinstance(other,int):

-            minElements, optElements = other,0

-        elif isinstance(other,tuple):

-            other = (other + (None, None))[:2]

-            if other[0] is None:

-                other = (0, other[1])

-            if isinstance(other[0],int) and other[1] is None:

-                if other[0] == 0:

-                    return ZeroOrMore(self)

-                if other[0] == 1:

-                    return OneOrMore(self)

-                else:

-                    return self*other[0] + ZeroOrMore(self)

-            elif isinstance(other[0],int) and isinstance(other[1],int):

-                minElements, optElements = other

-                optElements -= minElements

-            else:

-                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))

-        else:

-            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))

-

-        if minElements < 0:

-            raise ValueError("cannot multiply ParserElement by negative value")

-        if optElements < 0:

-            raise ValueError("second tuple value must be greater or equal to first tuple value")

-        if minElements == optElements == 0:

-            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")

-

-        if (optElements):

-            def makeOptionalList(n):

-                if n>1:

-                    return Optional(self + makeOptionalList(n-1))

-                else:

-                    return Optional(self)

-            if minElements:

-                if minElements == 1:

-                    ret = self + makeOptionalList(optElements)

-                else:

-                    ret = And([self]*minElements) + makeOptionalList(optElements)

-            else:

-                ret = makeOptionalList(optElements)

-        else:

-            if minElements == 1:

-                ret = self

-            else:

-                ret = And([self]*minElements)

-        return ret

-

-    def __rmul__(self, other):

-        return self.__mul__(other)

-

-    def __or__(self, other ):

-        """

-        Implementation of | operator - returns C{L{MatchFirst}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return MatchFirst( [ self, other ] )

-

-    def __ror__(self, other ):

-        """

-        Implementation of | operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other | self

-

-    def __xor__(self, other ):

-        """

-        Implementation of ^ operator - returns C{L{Or}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return Or( [ self, other ] )

-

-    def __rxor__(self, other ):

-        """

-        Implementation of ^ operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other ^ self

-

-    def __and__(self, other ):

-        """

-        Implementation of & operator - returns C{L{Each}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return Each( [ self, other ] )

-

-    def __rand__(self, other ):

-        """

-        Implementation of & operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other & self

-

-    def __invert__( self ):

-        """

-        Implementation of ~ operator - returns C{L{NotAny}}

-        """

-        return NotAny( self )

-

-    def __call__(self, name=None):

-        """

-        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.

-        

-        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be

-        passed as C{True}.

-           

-        If C{name} is omitted, same as calling C{L{copy}}.

-

-        Example::

-            # these are equivalent

-            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")

-            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             

-        """

-        if name is not None:

-            return self.setResultsName(name)

-        else:

-            return self.copy()

-

-    def suppress( self ):

-        """

-        Suppresses the output of this C{ParserElement}; useful to keep punctuation from

-        cluttering up returned output.

-        """

-        return Suppress( self )

-

-    def leaveWhitespace( self ):

-        """

-        Disables the skipping of whitespace before matching the characters in the

-        C{ParserElement}'s defined pattern.  This is normally only used internally by

-        the pyparsing module, but may be needed in some whitespace-sensitive grammars.

-        """

-        self.skipWhitespace = False

-        return self

-

-    def setWhitespaceChars( self, chars ):

-        """

-        Overrides the default whitespace chars

-        """

-        self.skipWhitespace = True

-        self.whiteChars = chars

-        self.copyDefaultWhiteChars = False

-        return self

-

-    def parseWithTabs( self ):

-        """

-        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string.

-        Must be called before C{parseString} when the input grammar contains elements that

-        match C{<TAB>} characters.

-        """

-        self.keepTabs = True

-        return self

-

-    def ignore( self, other ):

-        """

-        Define expression to be ignored (e.g., comments) while doing pattern

-        matching; may be called repeatedly, to define multiple comment or other

-        ignorable patterns.

-        

-        Example::

-            patt = OneOrMore(Word(alphas))

-            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']

-            

-            patt.ignore(cStyleComment)

-            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']

-        """

-        if isinstance(other, basestring):

-            other = Suppress(other)

-

-        if isinstance( other, Suppress ):

-            if other not in self.ignoreExprs:

-                self.ignoreExprs.append(other)

-        else:

-            self.ignoreExprs.append( Suppress( other.copy() ) )

-        return self

-

-    def setDebugActions( self, startAction, successAction, exceptionAction ):

-        """

-        Enable display of debugging messages while doing pattern matching.

-        """

-        self.debugActions = (startAction or _defaultStartDebugAction,

-                             successAction or _defaultSuccessDebugAction,

-                             exceptionAction or _defaultExceptionDebugAction)

-        self.debug = True

-        return self

-

-    def setDebug( self, flag=True ):

-        """

-        Enable display of debugging messages while doing pattern matching.

-        Set C{flag} to True to enable, False to disable.

-

-        Example::

-            wd = Word(alphas).setName("alphaword")

-            integer = Word(nums).setName("numword")

-            term = wd | integer

-            

-            # turn on debugging for wd

-            wd.setDebug()

-

-            OneOrMore(term).parseString("abc 123 xyz 890")

-        

-        prints::

-            Match alphaword at loc 0(1,1)

-            Matched alphaword -> ['abc']

-            Match alphaword at loc 3(1,4)

-            Exception raised:Expected alphaword (at char 4), (line:1, col:5)

-            Match alphaword at loc 7(1,8)

-            Matched alphaword -> ['xyz']

-            Match alphaword at loc 11(1,12)

-            Exception raised:Expected alphaword (at char 12), (line:1, col:13)

-            Match alphaword at loc 15(1,16)

-            Exception raised:Expected alphaword (at char 15), (line:1, col:16)

-

-        The output shown is that produced by the default debug actions - custom debug actions can be

-        specified using L{setDebugActions}. Prior to attempting

-        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"}

-        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}

-        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,

-        which makes debugging and exception messages easier to understand - for instance, the default

-        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.

-        """

-        if flag:

-            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )

-        else:

-            self.debug = False

-        return self

-

-    def __str__( self ):

-        return self.name

-

-    def __repr__( self ):

-        return _ustr(self)

-

-    def streamline( self ):

-        self.streamlined = True

-        self.strRepr = None

-        return self

-

-    def checkRecursion( self, parseElementList ):

-        pass

-

-    def validate( self, validateTrace=[] ):

-        """

-        Check defined expressions for valid structure, check for infinite recursive definitions.

-        """

-        self.checkRecursion( [] )

-

-    def parseFile( self, file_or_filename, parseAll=False ):

-        """

-        Execute the parse expression on the given file or filename.

-        If a filename is specified (instead of a file object),

-        the entire file is opened, read, and closed before parsing.

-        """

-        try:

-            file_contents = file_or_filename.read()

-        except AttributeError:

-            with open(file_or_filename, "r") as f:

-                file_contents = f.read()

-        try:

-            return self.parseString(file_contents, parseAll)

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def __eq__(self,other):

-        if isinstance(other, ParserElement):

-            return self is other or vars(self) == vars(other)

-        elif isinstance(other, basestring):

-            return self.matches(other)

-        else:

-            return super(ParserElement,self)==other

-

-    def __ne__(self,other):

-        return not (self == other)

-

-    def __hash__(self):

-        return hash(id(self))

-

-    def __req__(self,other):

-        return self == other

-

-    def __rne__(self,other):

-        return not (self == other)

-

-    def matches(self, testString, parseAll=True):

-        """

-        Method for quick testing of a parser against a test string. Good for simple 

-        inline microtests of sub expressions while building up larger parser.

-           

-        Parameters:

-         - testString - to test against this expression for a match

-         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests

-            

-        Example::

-            expr = Word(nums)

-            assert expr.matches("100")

-        """

-        try:

-            self.parseString(_ustr(testString), parseAll=parseAll)

-            return True

-        except ParseBaseException:

-            return False

-                

-    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):

-        """

-        Execute the parse expression on a series of test strings, showing each

-        test, the parsed results or where the parse failed. Quick and easy way to

-        run a parse expression against a list of sample strings.

-           

-        Parameters:

-         - tests - a list of separate test strings, or a multiline string of test strings

-         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           

-         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 

-              string; pass None to disable comment filtering

-         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;

-              if False, only dump nested list

-         - printResults - (default=C{True}) prints test output to stdout

-         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing

-

-        Returns: a (success, results) tuple, where success indicates that all tests succeeded

-        (or failed if C{failureTests} is True), and the results contain a list of lines of each 

-        test's output

-        

-        Example::

-            number_expr = pyparsing_common.number.copy()

-

-            result = number_expr.runTests('''

-                # unsigned integer

-                100

-                # negative integer

-                -100

-                # float with scientific notation

-                6.02e23

-                # integer with scientific notation

-                1e-12

-                ''')

-            print("Success" if result[0] else "Failed!")

-

-            result = number_expr.runTests('''

-                # stray character

-                100Z

-                # missing leading digit before '.'

-                -.100

-                # too many '.'

-                3.14.159

-                ''', failureTests=True)

-            print("Success" if result[0] else "Failed!")

-        prints::

-            # unsigned integer

-            100

-            [100]

-

-            # negative integer

-            -100

-            [-100]

-

-            # float with scientific notation

-            6.02e23

-            [6.02e+23]

-

-            # integer with scientific notation

-            1e-12

-            [1e-12]

-

-            Success

-            

-            # stray character

-            100Z

-               ^

-            FAIL: Expected end of text (at char 3), (line:1, col:4)

-

-            # missing leading digit before '.'

-            -.100

-            ^

-            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)

-

-            # too many '.'

-            3.14.159

-                ^

-            FAIL: Expected end of text (at char 4), (line:1, col:5)

-

-            Success

-

-        Each test string must be on a single line. If you want to test a string that spans multiple

-        lines, create a test like this::

-

-            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")

-        

-        (Note that this is a raw string literal, you must include the leading 'r'.)

-        """

-        if isinstance(tests, basestring):

-            tests = list(map(str.strip, tests.rstrip().splitlines()))

-        if isinstance(comment, basestring):

-            comment = Literal(comment)

-        allResults = []

-        comments = []

-        success = True

-        for t in tests:

-            if comment is not None and comment.matches(t, False) or comments and not t:

-                comments.append(t)

-                continue

-            if not t:

-                continue

-            out = ['\n'.join(comments), t]

-            comments = []

-            try:

-                t = t.replace(r'\n','\n')

-                result = self.parseString(t, parseAll=parseAll)

-                out.append(result.dump(full=fullDump))

-                success = success and not failureTests

-            except ParseBaseException as pe:

-                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""

-                if '\n' in t:

-                    out.append(line(pe.loc, t))

-                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)

-                else:

-                    out.append(' '*pe.loc + '^' + fatal)

-                out.append("FAIL: " + str(pe))

-                success = success and failureTests

-                result = pe

-            except Exception as exc:

-                out.append("FAIL-EXCEPTION: " + str(exc))

-                success = success and failureTests

-                result = exc

-

-            if printResults:

-                if fullDump:

-                    out.append('')

-                print('\n'.join(out))

-

-            allResults.append((t, result))

-        

-        return success, allResults

-

-        

-class Token(ParserElement):

-    """

-    Abstract C{ParserElement} subclass, for defining atomic matching patterns.

-    """

-    def __init__( self ):

-        super(Token,self).__init__( savelist=False )

-

-

-class Empty(Token):

-    """

-    An empty token, will always match.

-    """

-    def __init__( self ):

-        super(Empty,self).__init__()

-        self.name = "Empty"

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-

-

-class NoMatch(Token):

-    """

-    A token that will never match.

-    """

-    def __init__( self ):

-        super(NoMatch,self).__init__()

-        self.name = "NoMatch"

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-        self.errmsg = "Unmatchable token"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        raise ParseException(instring, loc, self.errmsg, self)

-

-

-class Literal(Token):

-    """

-    Token to exactly match a specified string.

-    

-    Example::

-        Literal('blah').parseString('blah')  # -> ['blah']

-        Literal('blah').parseString('blahfooblah')  # -> ['blah']

-        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"

-    

-    For case-insensitive matching, use L{CaselessLiteral}.

-    

-    For keyword matching (force word break before and after the matched string),

-    use L{Keyword} or L{CaselessKeyword}.

-    """

-    def __init__( self, matchString ):

-        super(Literal,self).__init__()

-        self.match = matchString

-        self.matchLen = len(matchString)

-        try:

-            self.firstMatchChar = matchString[0]

-        except IndexError:

-            warnings.warn("null string passed to Literal; use Empty() instead",

-                            SyntaxWarning, stacklevel=2)

-            self.__class__ = Empty

-        self.name = '"%s"' % _ustr(self.match)

-        self.errmsg = "Expected " + self.name

-        self.mayReturnEmpty = False

-        self.mayIndexError = False

-

-    # Performance tuning: this routine gets called a *lot*

-    # if this is a single character match string  and the first character matches,

-    # short-circuit as quickly as possible, and avoid calling startswith

-    #~ @profile

-    def parseImpl( self, instring, loc, doActions=True ):

-        if (instring[loc] == self.firstMatchChar and

-            (self.matchLen==1 or instring.startswith(self.match,loc)) ):

-            return loc+self.matchLen, self.match

-        raise ParseException(instring, loc, self.errmsg, self)

-_L = Literal

-ParserElement._literalStringClass = Literal

-

-class Keyword(Token):

-    """

-    Token to exactly match a specified string as a keyword, that is, it must be

-    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:

-     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.

-     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}

-    Accepts two optional constructor arguments in addition to the keyword string:

-     - C{identChars} is a string of characters that would be valid identifier characters,

-          defaulting to all alphanumerics + "_" and "$"

-     - C{caseless} allows case-insensitive matching, default is C{False}.

-       

-    Example::

-        Keyword("start").parseString("start")  # -> ['start']

-        Keyword("start").parseString("starting")  # -> Exception

-

-    For case-insensitive matching, use L{CaselessKeyword}.

-    """

-    DEFAULT_KEYWORD_CHARS = alphanums+"_$"

-

-    def __init__( self, matchString, identChars=None, caseless=False ):

-        super(Keyword,self).__init__()

-        if identChars is None:

-            identChars = Keyword.DEFAULT_KEYWORD_CHARS

-        self.match = matchString

-        self.matchLen = len(matchString)

-        try:

-            self.firstMatchChar = matchString[0]

-        except IndexError:

-            warnings.warn("null string passed to Keyword; use Empty() instead",

-                            SyntaxWarning, stacklevel=2)

-        self.name = '"%s"' % self.match

-        self.errmsg = "Expected " + self.name

-        self.mayReturnEmpty = False

-        self.mayIndexError = False

-        self.caseless = caseless

-        if caseless:

-            self.caselessmatch = matchString.upper()

-            identChars = identChars.upper()

-        self.identChars = set(identChars)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.caseless:

-            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and

-                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and

-                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):

-                return loc+self.matchLen, self.match

-        else:

-            if (instring[loc] == self.firstMatchChar and

-                (self.matchLen==1 or instring.startswith(self.match,loc)) and

-                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and

-                (loc == 0 or instring[loc-1] not in self.identChars) ):

-                return loc+self.matchLen, self.match

-        raise ParseException(instring, loc, self.errmsg, self)

-

-    def copy(self):

-        c = super(Keyword,self).copy()

-        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS

-        return c

-

-    @staticmethod

-    def setDefaultKeywordChars( chars ):

-        """Overrides the default Keyword chars

-        """

-        Keyword.DEFAULT_KEYWORD_CHARS = chars

-

-class CaselessLiteral(Literal):

-    """

-    Token to match a specified string, ignoring case of letters.

-    Note: the matched results will always be in the case of the given

-    match string, NOT the case of the input text.

-

-    Example::

-        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']

-        

-    (Contrast with example for L{CaselessKeyword}.)

-    """

-    def __init__( self, matchString ):

-        super(CaselessLiteral,self).__init__( matchString.upper() )

-        # Preserve the defining literal.

-        self.returnString = matchString

-        self.name = "'%s'" % self.returnString

-        self.errmsg = "Expected " + self.name

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if instring[ loc:loc+self.matchLen ].upper() == self.match:

-            return loc+self.matchLen, self.returnString

-        raise ParseException(instring, loc, self.errmsg, self)

-

-class CaselessKeyword(Keyword):

-    """

-    Caseless version of L{Keyword}.

-

-    Example::

-        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']

-        

-    (Contrast with example for L{CaselessLiteral}.)

-    """

-    def __init__( self, matchString, identChars=None ):

-        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and

-             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):

-            return loc+self.matchLen, self.match

-        raise ParseException(instring, loc, self.errmsg, self)

-

-class CloseMatch(Token):

-    """

-    A variation on L{Literal} which matches "close" matches, that is, 

-    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:

-     - C{match_string} - string to be matched

-     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match

-    

-    The results from a successful parse will contain the matched text from the input string and the following named results:

-     - C{mismatches} - a list of the positions within the match_string where mismatches were found

-     - C{original} - the original match_string used to compare against the input string

-    

-    If C{mismatches} is an empty list, then the match was an exact match.

-    

-    Example::

-        patt = CloseMatch("ATCATCGAATGGA")

-        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})

-        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)

-

-        # exact match

-        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})

-

-        # close match allowing up to 2 mismatches

-        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)

-        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})

-    """

-    def __init__(self, match_string, maxMismatches=1):

-        super(CloseMatch,self).__init__()

-        self.name = match_string

-        self.match_string = match_string

-        self.maxMismatches = maxMismatches

-        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)

-        self.mayIndexError = False

-        self.mayReturnEmpty = False

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        start = loc

-        instrlen = len(instring)

-        maxloc = start + len(self.match_string)

-

-        if maxloc <= instrlen:

-            match_string = self.match_string

-            match_stringloc = 0

-            mismatches = []

-            maxMismatches = self.maxMismatches

-

-            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):

-                src,mat = s_m

-                if src != mat:

-                    mismatches.append(match_stringloc)

-                    if len(mismatches) > maxMismatches:

-                        break

-            else:

-                loc = match_stringloc + 1

-                results = ParseResults([instring[start:loc]])

-                results['original'] = self.match_string

-                results['mismatches'] = mismatches

-                return loc, results

-

-        raise ParseException(instring, loc, self.errmsg, self)

-

-

-class Word(Token):

-    """

-    Token for matching words composed of allowed character sets.

-    Defined with string containing all allowed initial characters,

-    an optional string containing allowed body characters (if omitted,

-    defaults to the initial character set), and an optional minimum,

-    maximum, and/or exact length.  The default value for C{min} is 1 (a

-    minimum value < 1 is not valid); the default values for C{max} and C{exact}

-    are 0, meaning no maximum or exact length restriction. An optional

-    C{excludeChars} parameter can list characters that might be found in 

-    the input C{bodyChars} string; useful to define a word of all printables

-    except for one or two characters, for instance.

-    

-    L{srange} is useful for defining custom character set strings for defining 

-    C{Word} expressions, using range notation from regular expression character sets.

-    

-    A common mistake is to use C{Word} to match a specific literal string, as in 

-    C{Word("Address")}. Remember that C{Word} uses the string argument to define

-    I{sets} of matchable characters. This expression would match "Add", "AAA",

-    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.

-    To match an exact literal string, use L{Literal} or L{Keyword}.

-

-    pyparsing includes helper strings for building Words:

-     - L{alphas}

-     - L{nums}

-     - L{alphanums}

-     - L{hexnums}

-     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)

-     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)

-     - L{printables} (any non-whitespace character)

-

-    Example::

-        # a word composed of digits

-        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))

-        

-        # a word with a leading capital, and zero or more lowercase

-        capital_word = Word(alphas.upper(), alphas.lower())

-

-        # hostnames are alphanumeric, with leading alpha, and '-'

-        hostname = Word(alphas, alphanums+'-')

-        

-        # roman numeral (not a strict parser, accepts invalid mix of characters)

-        roman = Word("IVXLCDM")

-        

-        # any string of non-whitespace characters, except for ','

-        csv_value = Word(printables, excludeChars=",")

-    """

-    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):

-        super(Word,self).__init__()

-        if excludeChars:

-            initChars = ''.join(c for c in initChars if c not in excludeChars)

-            if bodyChars:

-                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)

-        self.initCharsOrig = initChars

-        self.initChars = set(initChars)

-        if bodyChars :

-            self.bodyCharsOrig = bodyChars

-            self.bodyChars = set(bodyChars)

-        else:

-            self.bodyCharsOrig = initChars

-            self.bodyChars = set(initChars)

-

-        self.maxSpecified = max > 0

-

-        if min < 1:

-            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")

-

-        self.minLen = min

-

-        if max > 0:

-            self.maxLen = max

-        else:

-            self.maxLen = _MAX_INT

-

-        if exact > 0:

-            self.maxLen = exact

-            self.minLen = exact

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayIndexError = False

-        self.asKeyword = asKeyword

-

-        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):

-            if self.bodyCharsOrig == self.initCharsOrig:

-                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)

-            elif len(self.initCharsOrig) == 1:

-                self.reString = "%s[%s]*" % \

-                                      (re.escape(self.initCharsOrig),

-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)

-            else:

-                self.reString = "[%s][%s]*" % \

-                                      (_escapeRegexRangeChars(self.initCharsOrig),

-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)

-            if self.asKeyword:

-                self.reString = r"\b"+self.reString+r"\b"

-            try:

-                self.re = re.compile( self.reString )

-            except Exception:

-                self.re = None

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.re:

-            result = self.re.match(instring,loc)

-            if not result:

-                raise ParseException(instring, loc, self.errmsg, self)

-

-            loc = result.end()

-            return loc, result.group()

-

-        if not(instring[ loc ] in self.initChars):

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        start = loc

-        loc += 1

-        instrlen = len(instring)

-        bodychars = self.bodyChars

-        maxloc = start + self.maxLen

-        maxloc = min( maxloc, instrlen )

-        while loc < maxloc and instring[loc] in bodychars:

-            loc += 1

-

-        throwException = False

-        if loc - start < self.minLen:

-            throwException = True

-        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:

-            throwException = True

-        if self.asKeyword:

-            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):

-                throwException = True

-

-        if throwException:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        return loc, instring[start:loc]

-

-    def __str__( self ):

-        try:

-            return super(Word,self).__str__()

-        except Exception:

-            pass

-

-

-        if self.strRepr is None:

-

-            def charsAsStr(s):

-                if len(s)>4:

-                    return s[:4]+"..."

-                else:

-                    return s

-

-            if ( self.initCharsOrig != self.bodyCharsOrig ):

-                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )

-            else:

-                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)

-

-        return self.strRepr

-

-

-class Regex(Token):

-    r"""

-    Token for matching strings that match a given regular expression.

-    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.

-    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as 

-    named parse results.

-

-    Example::

-        realnum = Regex(r"[+-]?\d+\.\d*")

-        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')

-        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression

-        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")

-    """

-    compiledREtype = type(re.compile("[A-Z]"))

-    def __init__( self, pattern, flags=0):

-        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""

-        super(Regex,self).__init__()

-

-        if isinstance(pattern, basestring):

-            if not pattern:

-                warnings.warn("null string passed to Regex; use Empty() instead",

-                        SyntaxWarning, stacklevel=2)

-

-            self.pattern = pattern

-            self.flags = flags

-

-            try:

-                self.re = re.compile(self.pattern, self.flags)

-                self.reString = self.pattern

-            except sre_constants.error:

-                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,

-                    SyntaxWarning, stacklevel=2)

-                raise

-

-        elif isinstance(pattern, Regex.compiledREtype):

-            self.re = pattern

-            self.pattern = \

-            self.reString = str(pattern)

-            self.flags = flags

-            

-        else:

-            raise ValueError("Regex may only be constructed with a string or a compiled RE object")

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayIndexError = False

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        result = self.re.match(instring,loc)

-        if not result:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        loc = result.end()

-        d = result.groupdict()

-        ret = ParseResults(result.group())

-        if d:

-            for k in d:

-                ret[k] = d[k]

-        return loc,ret

-

-    def __str__( self ):

-        try:

-            return super(Regex,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            self.strRepr = "Re:(%s)" % repr(self.pattern)

-

-        return self.strRepr

-

-

-class QuotedString(Token):

-    r"""

-    Token for matching strings that are delimited by quoting characters.

-    

-    Defined with the following parameters:

-        - quoteChar - string of one or more characters defining the quote delimiting string

-        - escChar - character to escape quotes, typically backslash (default=C{None})

-        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})

-        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})

-        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})

-        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)

-        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})

-

-    Example::

-        qs = QuotedString('"')

-        print(qs.searchString('lsjdf "This is the quote" sldjf'))

-        complex_qs = QuotedString('{{', endQuoteChar='}}')

-        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))

-        sql_qs = QuotedString('"', escQuote='""')

-        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))

-    prints::

-        [['This is the quote']]

-        [['This is the "quote"']]

-        [['This is the quote with "embedded" quotes']]

-    """

-    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):

-        super(QuotedString,self).__init__()

-

-        # remove white space from quote chars - wont work anyway

-        quoteChar = quoteChar.strip()

-        if not quoteChar:

-            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)

-            raise SyntaxError()

-

-        if endQuoteChar is None:

-            endQuoteChar = quoteChar

-        else:

-            endQuoteChar = endQuoteChar.strip()

-            if not endQuoteChar:

-                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)

-                raise SyntaxError()

-

-        self.quoteChar = quoteChar

-        self.quoteCharLen = len(quoteChar)

-        self.firstQuoteChar = quoteChar[0]

-        self.endQuoteChar = endQuoteChar

-        self.endQuoteCharLen = len(endQuoteChar)

-        self.escChar = escChar

-        self.escQuote = escQuote

-        self.unquoteResults = unquoteResults

-        self.convertWhitespaceEscapes = convertWhitespaceEscapes

-

-        if multiline:

-            self.flags = re.MULTILINE | re.DOTALL

-            self.pattern = r'%s(?:[^%s%s]' % \

-                ( re.escape(self.quoteChar),

-                  _escapeRegexRangeChars(self.endQuoteChar[0]),

-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )

-        else:

-            self.flags = 0

-            self.pattern = r'%s(?:[^%s\n\r%s]' % \

-                ( re.escape(self.quoteChar),

-                  _escapeRegexRangeChars(self.endQuoteChar[0]),

-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )

-        if len(self.endQuoteChar) > 1:

-            self.pattern += (

-                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),

-                                               _escapeRegexRangeChars(self.endQuoteChar[i]))

-                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'

-                )

-        if escQuote:

-            self.pattern += (r'|(?:%s)' % re.escape(escQuote))

-        if escChar:

-            self.pattern += (r'|(?:%s.)' % re.escape(escChar))

-            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"

-        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))

-

-        try:

-            self.re = re.compile(self.pattern, self.flags)

-            self.reString = self.pattern

-        except sre_constants.error:

-            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,

-                SyntaxWarning, stacklevel=2)

-            raise

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayIndexError = False

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None

-        if not result:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        loc = result.end()

-        ret = result.group()

-

-        if self.unquoteResults:

-

-            # strip off quotes

-            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]

-

-            if isinstance(ret,basestring):

-                # replace escaped whitespace

-                if '\\' in ret and self.convertWhitespaceEscapes:

-                    ws_map = {

-                        r'\t' : '\t',

-                        r'\n' : '\n',

-                        r'\f' : '\f',

-                        r'\r' : '\r',

-                    }

-                    for wslit,wschar in ws_map.items():

-                        ret = ret.replace(wslit, wschar)

-

-                # replace escaped characters

-                if self.escChar:

-                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)

-

-                # replace escaped quotes

-                if self.escQuote:

-                    ret = ret.replace(self.escQuote, self.endQuoteChar)

-

-        return loc, ret

-

-    def __str__( self ):

-        try:

-            return super(QuotedString,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)

-

-        return self.strRepr

-

-

-class CharsNotIn(Token):

-    """

-    Token for matching words composed of characters I{not} in a given set (will

-    include whitespace in matched characters if not listed in the provided exclusion set - see example).

-    Defined with string containing all disallowed characters, and an optional

-    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a

-    minimum value < 1 is not valid); the default values for C{max} and C{exact}

-    are 0, meaning no maximum or exact length restriction.

-

-    Example::

-        # define a comma-separated-value as anything that is not a ','

-        csv_value = CharsNotIn(',')

-        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))

-    prints::

-        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']

-    """

-    def __init__( self, notChars, min=1, max=0, exact=0 ):

-        super(CharsNotIn,self).__init__()

-        self.skipWhitespace = False

-        self.notChars = notChars

-

-        if min < 1:

-            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")

-

-        self.minLen = min

-

-        if max > 0:

-            self.maxLen = max

-        else:

-            self.maxLen = _MAX_INT

-

-        if exact > 0:

-            self.maxLen = exact

-            self.minLen = exact

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayReturnEmpty = ( self.minLen == 0 )

-        self.mayIndexError = False

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if instring[loc] in self.notChars:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        start = loc

-        loc += 1

-        notchars = self.notChars

-        maxlen = min( start+self.maxLen, len(instring) )

-        while loc < maxlen and \

-              (instring[loc] not in notchars):

-            loc += 1

-

-        if loc - start < self.minLen:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        return loc, instring[start:loc]

-

-    def __str__( self ):

-        try:

-            return super(CharsNotIn, self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            if len(self.notChars) > 4:

-                self.strRepr = "!W:(%s...)" % self.notChars[:4]

-            else:

-                self.strRepr = "!W:(%s)" % self.notChars

-

-        return self.strRepr

-

-class White(Token):

-    """

-    Special matching class for matching whitespace.  Normally, whitespace is ignored

-    by pyparsing grammars.  This class is included when some whitespace structures

-    are significant.  Define with a string containing the whitespace characters to be

-    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,

-    as defined for the C{L{Word}} class.

-    """

-    whiteStrs = {

-        " " : "<SPC>",

-        "\t": "<TAB>",

-        "\n": "<LF>",

-        "\r": "<CR>",

-        "\f": "<FF>",

-        }

-    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):

-        super(White,self).__init__()

-        self.matchWhite = ws

-        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )

-        #~ self.leaveWhitespace()

-        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))

-        self.mayReturnEmpty = True

-        self.errmsg = "Expected " + self.name

-

-        self.minLen = min

-

-        if max > 0:

-            self.maxLen = max

-        else:

-            self.maxLen = _MAX_INT

-

-        if exact > 0:

-            self.maxLen = exact

-            self.minLen = exact

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if not(instring[ loc ] in self.matchWhite):

-            raise ParseException(instring, loc, self.errmsg, self)

-        start = loc

-        loc += 1

-        maxloc = start + self.maxLen

-        maxloc = min( maxloc, len(instring) )

-        while loc < maxloc and instring[loc] in self.matchWhite:

-            loc += 1

-

-        if loc - start < self.minLen:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        return loc, instring[start:loc]

-

-

-class _PositionToken(Token):

-    def __init__( self ):

-        super(_PositionToken,self).__init__()

-        self.name=self.__class__.__name__

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-

-class GoToColumn(_PositionToken):

-    """

-    Token to advance to a specific column of input text; useful for tabular report scraping.

-    """

-    def __init__( self, colno ):

-        super(GoToColumn,self).__init__()

-        self.col = colno

-

-    def preParse( self, instring, loc ):

-        if col(loc,instring) != self.col:

-            instrlen = len(instring)

-            if self.ignoreExprs:

-                loc = self._skipIgnorables( instring, loc )

-            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :

-                loc += 1

-        return loc

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        thiscol = col( loc, instring )

-        if thiscol > self.col:

-            raise ParseException( instring, loc, "Text not in expected column", self )

-        newloc = loc + self.col - thiscol

-        ret = instring[ loc: newloc ]

-        return newloc, ret

-

-

-class LineStart(_PositionToken):

-    """

-    Matches if current position is at the beginning of a line within the parse string

-    

-    Example::

-    

-        test = '''\

-        AAA this line

-        AAA and this line

-          AAA but not this one

-        B AAA and definitely not this one

-        '''

-

-        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):

-            print(t)

-    

-    Prints::

-        ['AAA', ' this line']

-        ['AAA', ' and this line']    

-

-    """

-    def __init__( self ):

-        super(LineStart,self).__init__()

-        self.errmsg = "Expected start of line"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if col(loc, instring) == 1:

-            return loc, []

-        raise ParseException(instring, loc, self.errmsg, self)

-

-class LineEnd(_PositionToken):

-    """

-    Matches if current position is at the end of a line within the parse string

-    """

-    def __init__( self ):

-        super(LineEnd,self).__init__()

-        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )

-        self.errmsg = "Expected end of line"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if loc<len(instring):

-            if instring[loc] == "\n":

-                return loc+1, "\n"

-            else:

-                raise ParseException(instring, loc, self.errmsg, self)

-        elif loc == len(instring):

-            return loc+1, []

-        else:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-class StringStart(_PositionToken):

-    """

-    Matches if current position is at the beginning of the parse string

-    """

-    def __init__( self ):

-        super(StringStart,self).__init__()

-        self.errmsg = "Expected start of text"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if loc != 0:

-            # see if entire string up to here is just whitespace and ignoreables

-            if loc != self.preParse( instring, 0 ):

-                raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-class StringEnd(_PositionToken):

-    """

-    Matches if current position is at the end of the parse string

-    """

-    def __init__( self ):

-        super(StringEnd,self).__init__()

-        self.errmsg = "Expected end of text"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if loc < len(instring):

-            raise ParseException(instring, loc, self.errmsg, self)

-        elif loc == len(instring):

-            return loc+1, []

-        elif loc > len(instring):

-            return loc, []

-        else:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-class WordStart(_PositionToken):

-    """

-    Matches if the current position is at the beginning of a Word, and

-    is not preceded by any character in a given set of C{wordChars}

-    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,

-    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of

-    the string being parsed, or at the beginning of a line.

-    """

-    def __init__(self, wordChars = printables):

-        super(WordStart,self).__init__()

-        self.wordChars = set(wordChars)

-        self.errmsg = "Not at the start of a word"

-

-    def parseImpl(self, instring, loc, doActions=True ):

-        if loc != 0:

-            if (instring[loc-1] in self.wordChars or

-                instring[loc] not in self.wordChars):

-                raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-class WordEnd(_PositionToken):

-    """

-    Matches if the current position is at the end of a Word, and

-    is not followed by any character in a given set of C{wordChars}

-    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,

-    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of

-    the string being parsed, or at the end of a line.

-    """

-    def __init__(self, wordChars = printables):

-        super(WordEnd,self).__init__()

-        self.wordChars = set(wordChars)

-        self.skipWhitespace = False

-        self.errmsg = "Not at the end of a word"

-

-    def parseImpl(self, instring, loc, doActions=True ):

-        instrlen = len(instring)

-        if instrlen>0 and loc<instrlen:

-            if (instring[loc] in self.wordChars or

-                instring[loc-1] not in self.wordChars):

-                raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-

-class ParseExpression(ParserElement):

-    """

-    Abstract subclass of ParserElement, for combining and post-processing parsed tokens.

-    """

-    def __init__( self, exprs, savelist = False ):

-        super(ParseExpression,self).__init__(savelist)

-        if isinstance( exprs, _generatorType ):

-            exprs = list(exprs)

-

-        if isinstance( exprs, basestring ):

-            self.exprs = [ ParserElement._literalStringClass( exprs ) ]

-        elif isinstance( exprs, Iterable ):

-            exprs = list(exprs)

-            # if sequence of strings provided, wrap with Literal

-            if all(isinstance(expr, basestring) for expr in exprs):

-                exprs = map(ParserElement._literalStringClass, exprs)

-            self.exprs = list(exprs)

-        else:

-            try:

-                self.exprs = list( exprs )

-            except TypeError:

-                self.exprs = [ exprs ]

-        self.callPreparse = False

-

-    def __getitem__( self, i ):

-        return self.exprs[i]

-

-    def append( self, other ):

-        self.exprs.append( other )

-        self.strRepr = None

-        return self

-

-    def leaveWhitespace( self ):

-        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on

-           all contained expressions."""

-        self.skipWhitespace = False

-        self.exprs = [ e.copy() for e in self.exprs ]

-        for e in self.exprs:

-            e.leaveWhitespace()

-        return self

-

-    def ignore( self, other ):

-        if isinstance( other, Suppress ):

-            if other not in self.ignoreExprs:

-                super( ParseExpression, self).ignore( other )

-                for e in self.exprs:

-                    e.ignore( self.ignoreExprs[-1] )

-        else:

-            super( ParseExpression, self).ignore( other )

-            for e in self.exprs:

-                e.ignore( self.ignoreExprs[-1] )

-        return self

-

-    def __str__( self ):

-        try:

-            return super(ParseExpression,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )

-        return self.strRepr

-

-    def streamline( self ):

-        super(ParseExpression,self).streamline()

-

-        for e in self.exprs:

-            e.streamline()

-

-        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )

-        # but only if there are no parse actions or resultsNames on the nested And's

-        # (likewise for Or's and MatchFirst's)

-        if ( len(self.exprs) == 2 ):

-            other = self.exprs[0]

-            if ( isinstance( other, self.__class__ ) and

-                  not(other.parseAction) and

-                  other.resultsName is None and

-                  not other.debug ):

-                self.exprs = other.exprs[:] + [ self.exprs[1] ]

-                self.strRepr = None

-                self.mayReturnEmpty |= other.mayReturnEmpty

-                self.mayIndexError  |= other.mayIndexError

-

-            other = self.exprs[-1]

-            if ( isinstance( other, self.__class__ ) and

-                  not(other.parseAction) and

-                  other.resultsName is None and

-                  not other.debug ):

-                self.exprs = self.exprs[:-1] + other.exprs[:]

-                self.strRepr = None

-                self.mayReturnEmpty |= other.mayReturnEmpty

-                self.mayIndexError  |= other.mayIndexError

-

-        self.errmsg = "Expected " + _ustr(self)

-        

-        return self

-

-    def setResultsName( self, name, listAllMatches=False ):

-        ret = super(ParseExpression,self).setResultsName(name,listAllMatches)

-        return ret

-

-    def validate( self, validateTrace=[] ):

-        tmp = validateTrace[:]+[self]

-        for e in self.exprs:

-            e.validate(tmp)

-        self.checkRecursion( [] )

-        

-    def copy(self):

-        ret = super(ParseExpression,self).copy()

-        ret.exprs = [e.copy() for e in self.exprs]

-        return ret

-

-class And(ParseExpression):

-    """

-    Requires all given C{ParseExpression}s to be found in the given order.

-    Expressions may be separated by whitespace.

-    May be constructed using the C{'+'} operator.

-    May also be constructed using the C{'-'} operator, which will suppress backtracking.

-

-    Example::

-        integer = Word(nums)

-        name_expr = OneOrMore(Word(alphas))

-

-        expr = And([integer("id"),name_expr("name"),integer("age")])

-        # more easily written as:

-        expr = integer("id") + name_expr("name") + integer("age")

-    """

-

-    class _ErrorStop(Empty):

-        def __init__(self, *args, **kwargs):

-            super(And._ErrorStop,self).__init__(*args, **kwargs)

-            self.name = '-'

-            self.leaveWhitespace()

-

-    def __init__( self, exprs, savelist = True ):

-        super(And,self).__init__(exprs, savelist)

-        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)

-        self.setWhitespaceChars( self.exprs[0].whiteChars )

-        self.skipWhitespace = self.exprs[0].skipWhitespace

-        self.callPreparse = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        # pass False as last arg to _parse for first element, since we already

-        # pre-parsed the string as part of our And pre-parsing

-        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )

-        errorStop = False

-        for e in self.exprs[1:]:

-            if isinstance(e, And._ErrorStop):

-                errorStop = True

-                continue

-            if errorStop:

-                try:

-                    loc, exprtokens = e._parse( instring, loc, doActions )

-                except ParseSyntaxException:

-                    raise

-                except ParseBaseException as pe:

-                    pe.__traceback__ = None

-                    raise ParseSyntaxException._from_exception(pe)

-                except IndexError:

-                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self)

-            else:

-                loc, exprtokens = e._parse( instring, loc, doActions )

-            if exprtokens or exprtokens.haskeys():

-                resultlist += exprtokens

-        return loc, resultlist

-

-    def __iadd__(self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        return self.append( other ) #And( [ self, other ] )

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-            if not e.mayReturnEmpty:

-                break

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-

-class Or(ParseExpression):

-    """

-    Requires that at least one C{ParseExpression} is found.

-    If two expressions match, the expression that matches the longest string will be used.

-    May be constructed using the C{'^'} operator.

-

-    Example::

-        # construct Or using '^' operator

-        

-        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))

-        print(number.searchString("123 3.1416 789"))

-    prints::

-        [['123'], ['3.1416'], ['789']]

-    """

-    def __init__( self, exprs, savelist = False ):

-        super(Or,self).__init__(exprs, savelist)

-        if self.exprs:

-            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)

-        else:

-            self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        maxExcLoc = -1

-        maxException = None

-        matches = []

-        for e in self.exprs:

-            try:

-                loc2 = e.tryParse( instring, loc )

-            except ParseException as err:

-                err.__traceback__ = None

-                if err.loc > maxExcLoc:

-                    maxException = err

-                    maxExcLoc = err.loc

-            except IndexError:

-                if len(instring) > maxExcLoc:

-                    maxException = ParseException(instring,len(instring),e.errmsg,self)

-                    maxExcLoc = len(instring)

-            else:

-                # save match among all matches, to retry longest to shortest

-                matches.append((loc2, e))

-

-        if matches:

-            matches.sort(key=lambda x: -x[0])

-            for _,e in matches:

-                try:

-                    return e._parse( instring, loc, doActions )

-                except ParseException as err:

-                    err.__traceback__ = None

-                    if err.loc > maxExcLoc:

-                        maxException = err

-                        maxExcLoc = err.loc

-

-        if maxException is not None:

-            maxException.msg = self.errmsg

-            raise maxException

-        else:

-            raise ParseException(instring, loc, "no defined alternatives to match", self)

-

-

-    def __ixor__(self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        return self.append( other ) #Or( [ self, other ] )

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-

-

-class MatchFirst(ParseExpression):

-    """

-    Requires that at least one C{ParseExpression} is found.

-    If two expressions match, the first one listed is the one that will match.

-    May be constructed using the C{'|'} operator.

-

-    Example::

-        # construct MatchFirst using '|' operator

-        

-        # watch the order of expressions to match

-        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))

-        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]

-

-        # put more selective expression first

-        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)

-        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]

-    """

-    def __init__( self, exprs, savelist = False ):

-        super(MatchFirst,self).__init__(exprs, savelist)

-        if self.exprs:

-            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)

-        else:

-            self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        maxExcLoc = -1

-        maxException = None

-        for e in self.exprs:

-            try:

-                ret = e._parse( instring, loc, doActions )

-                return ret

-            except ParseException as err:

-                if err.loc > maxExcLoc:

-                    maxException = err

-                    maxExcLoc = err.loc

-            except IndexError:

-                if len(instring) > maxExcLoc:

-                    maxException = ParseException(instring,len(instring),e.errmsg,self)

-                    maxExcLoc = len(instring)

-

-        # only got here if no expression matched, raise exception for match that made it the furthest

-        else:

-            if maxException is not None:

-                maxException.msg = self.errmsg

-                raise maxException

-            else:

-                raise ParseException(instring, loc, "no defined alternatives to match", self)

-

-    def __ior__(self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        return self.append( other ) #MatchFirst( [ self, other ] )

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-

-

-class Each(ParseExpression):

-    """

-    Requires all given C{ParseExpression}s to be found, but in any order.

-    Expressions may be separated by whitespace.

-    May be constructed using the C{'&'} operator.

-

-    Example::

-        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")

-        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")

-        integer = Word(nums)

-        shape_attr = "shape:" + shape_type("shape")

-        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")

-        color_attr = "color:" + color("color")

-        size_attr = "size:" + integer("size")

-

-        # use Each (using operator '&') to accept attributes in any order 

-        # (shape and posn are required, color and size are optional)

-        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)

-

-        shape_spec.runTests('''

-            shape: SQUARE color: BLACK posn: 100, 120

-            shape: CIRCLE size: 50 color: BLUE posn: 50,80

-            color:GREEN size:20 shape:TRIANGLE posn:20,40

-            '''

-            )

-    prints::

-        shape: SQUARE color: BLACK posn: 100, 120

-        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]

-        - color: BLACK

-        - posn: ['100', ',', '120']

-          - x: 100

-          - y: 120

-        - shape: SQUARE

-

-

-        shape: CIRCLE size: 50 color: BLUE posn: 50,80

-        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]

-        - color: BLUE

-        - posn: ['50', ',', '80']

-          - x: 50

-          - y: 80

-        - shape: CIRCLE

-        - size: 50

-

-

-        color: GREEN size: 20 shape: TRIANGLE posn: 20,40

-        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]

-        - color: GREEN

-        - posn: ['20', ',', '40']

-          - x: 20

-          - y: 40

-        - shape: TRIANGLE

-        - size: 20

-    """

-    def __init__( self, exprs, savelist = True ):

-        super(Each,self).__init__(exprs, savelist)

-        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)

-        self.skipWhitespace = True

-        self.initExprGroups = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.initExprGroups:

-            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))

-            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]

-            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]

-            self.optionals = opt1 + opt2

-            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]

-            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]

-            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]

-            self.required += self.multirequired

-            self.initExprGroups = False

-        tmpLoc = loc

-        tmpReqd = self.required[:]

-        tmpOpt  = self.optionals[:]

-        matchOrder = []

-

-        keepMatching = True

-        while keepMatching:

-            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired

-            failed = []

-            for e in tmpExprs:

-                try:

-                    tmpLoc = e.tryParse( instring, tmpLoc )

-                except ParseException:

-                    failed.append(e)

-                else:

-                    matchOrder.append(self.opt1map.get(id(e),e))

-                    if e in tmpReqd:

-                        tmpReqd.remove(e)

-                    elif e in tmpOpt:

-                        tmpOpt.remove(e)

-            if len(failed) == len(tmpExprs):

-                keepMatching = False

-

-        if tmpReqd:

-            missing = ", ".join(_ustr(e) for e in tmpReqd)

-            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )

-

-        # add any unmatched Optionals, in case they have default values defined

-        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]

-

-        resultlist = []

-        for e in matchOrder:

-            loc,results = e._parse(instring,loc,doActions)

-            resultlist.append(results)

-

-        finalResults = sum(resultlist, ParseResults([]))

-        return loc, finalResults

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-

-

-class ParseElementEnhance(ParserElement):

-    """

-    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.

-    """

-    def __init__( self, expr, savelist=False ):

-        super(ParseElementEnhance,self).__init__(savelist)

-        if isinstance( expr, basestring ):

-            if issubclass(ParserElement._literalStringClass, Token):

-                expr = ParserElement._literalStringClass(expr)

-            else:

-                expr = ParserElement._literalStringClass(Literal(expr))

-        self.expr = expr

-        self.strRepr = None

-        if expr is not None:

-            self.mayIndexError = expr.mayIndexError

-            self.mayReturnEmpty = expr.mayReturnEmpty

-            self.setWhitespaceChars( expr.whiteChars )

-            self.skipWhitespace = expr.skipWhitespace

-            self.saveAsList = expr.saveAsList

-            self.callPreparse = expr.callPreparse

-            self.ignoreExprs.extend(expr.ignoreExprs)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.expr is not None:

-            return self.expr._parse( instring, loc, doActions, callPreParse=False )

-        else:

-            raise ParseException("",loc,self.errmsg,self)

-

-    def leaveWhitespace( self ):

-        self.skipWhitespace = False

-        self.expr = self.expr.copy()

-        if self.expr is not None:

-            self.expr.leaveWhitespace()

-        return self

-

-    def ignore( self, other ):

-        if isinstance( other, Suppress ):

-            if other not in self.ignoreExprs:

-                super( ParseElementEnhance, self).ignore( other )

-                if self.expr is not None:

-                    self.expr.ignore( self.ignoreExprs[-1] )

-        else:

-            super( ParseElementEnhance, self).ignore( other )

-            if self.expr is not None:

-                self.expr.ignore( self.ignoreExprs[-1] )

-        return self

-

-    def streamline( self ):

-        super(ParseElementEnhance,self).streamline()

-        if self.expr is not None:

-            self.expr.streamline()

-        return self

-

-    def checkRecursion( self, parseElementList ):

-        if self in parseElementList:

-            raise RecursiveGrammarException( parseElementList+[self] )

-        subRecCheckList = parseElementList[:] + [ self ]

-        if self.expr is not None:

-            self.expr.checkRecursion( subRecCheckList )

-

-    def validate( self, validateTrace=[] ):

-        tmp = validateTrace[:]+[self]

-        if self.expr is not None:

-            self.expr.validate(tmp)

-        self.checkRecursion( [] )

-

-    def __str__( self ):

-        try:

-            return super(ParseElementEnhance,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None and self.expr is not None:

-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )

-        return self.strRepr

-

-

-class FollowedBy(ParseElementEnhance):

-    """

-    Lookahead matching of the given parse expression.  C{FollowedBy}

-    does I{not} advance the parsing position within the input string, it only

-    verifies that the specified parse expression matches at the current

-    position.  C{FollowedBy} always returns a null token list.

-

-    Example::

-        # use FollowedBy to match a label only if it is followed by a ':'

-        data_word = Word(alphas)

-        label = data_word + FollowedBy(':')

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        

-        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()

-    prints::

-        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]

-    """

-    def __init__( self, expr ):

-        super(FollowedBy,self).__init__(expr)

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        self.expr.tryParse( instring, loc )

-        return loc, []

-

-

-class NotAny(ParseElementEnhance):

-    """

-    Lookahead to disallow matching with the given parse expression.  C{NotAny}

-    does I{not} advance the parsing position within the input string, it only

-    verifies that the specified parse expression does I{not} match at the current

-    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}

-    always returns a null token list.  May be constructed using the '~' operator.

-

-    Example::

-        

-    """

-    def __init__( self, expr ):

-        super(NotAny,self).__init__(expr)

-        #~ self.leaveWhitespace()

-        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs

-        self.mayReturnEmpty = True

-        self.errmsg = "Found unwanted token, "+_ustr(self.expr)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.expr.canParseNext(instring, loc):

-            raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "~{" + _ustr(self.expr) + "}"

-

-        return self.strRepr

-

-class _MultipleMatch(ParseElementEnhance):

-    def __init__( self, expr, stopOn=None):

-        super(_MultipleMatch, self).__init__(expr)

-        self.saveAsList = True

-        ender = stopOn

-        if isinstance(ender, basestring):

-            ender = ParserElement._literalStringClass(ender)

-        self.not_ender = ~ender if ender is not None else None

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        self_expr_parse = self.expr._parse

-        self_skip_ignorables = self._skipIgnorables

-        check_ender = self.not_ender is not None

-        if check_ender:

-            try_not_ender = self.not_ender.tryParse

-        

-        # must be at least one (but first see if we are the stopOn sentinel;

-        # if so, fail)

-        if check_ender:

-            try_not_ender(instring, loc)

-        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )

-        try:

-            hasIgnoreExprs = (not not self.ignoreExprs)

-            while 1:

-                if check_ender:

-                    try_not_ender(instring, loc)

-                if hasIgnoreExprs:

-                    preloc = self_skip_ignorables( instring, loc )

-                else:

-                    preloc = loc

-                loc, tmptokens = self_expr_parse( instring, preloc, doActions )

-                if tmptokens or tmptokens.haskeys():

-                    tokens += tmptokens

-        except (ParseException,IndexError):

-            pass

-

-        return loc, tokens

-        

-class OneOrMore(_MultipleMatch):

-    """

-    Repetition of one or more of the given expression.

-    

-    Parameters:

-     - expr - expression that must match one or more times

-     - stopOn - (default=C{None}) - expression for a terminating sentinel

-          (only required if the sentinel would ordinarily match the repetition 

-          expression)          

-

-    Example::

-        data_word = Word(alphas)

-        label = data_word + FollowedBy(':')

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

-

-        text = "shape: SQUARE posn: upper left color: BLACK"

-        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]

-

-        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]

-        

-        # could also be written as

-        (attr_expr * (1,)).parseString(text).pprint()

-    """

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + _ustr(self.expr) + "}..."

-

-        return self.strRepr

-

-class ZeroOrMore(_MultipleMatch):

-    """

-    Optional repetition of zero or more of the given expression.

-    

-    Parameters:

-     - expr - expression that must match zero or more times

-     - stopOn - (default=C{None}) - expression for a terminating sentinel

-          (only required if the sentinel would ordinarily match the repetition 

-          expression)          

-

-    Example: similar to L{OneOrMore}

-    """

-    def __init__( self, expr, stopOn=None):

-        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)

-        self.mayReturnEmpty = True

-        

-    def parseImpl( self, instring, loc, doActions=True ):

-        try:

-            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)

-        except (ParseException,IndexError):

-            return loc, []

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "[" + _ustr(self.expr) + "]..."

-

-        return self.strRepr

-

-class _NullToken(object):

-    def __bool__(self):

-        return False

-    __nonzero__ = __bool__

-    def __str__(self):

-        return ""

-

-_optionalNotMatched = _NullToken()

-class Optional(ParseElementEnhance):

-    """

-    Optional matching of the given expression.

-

-    Parameters:

-     - expr - expression that must match zero or more times

-     - default (optional) - value to be returned if the optional expression is not found.

-

-    Example::

-        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier

-        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))

-        zip.runTests('''

-            # traditional ZIP code

-            12345

-            

-            # ZIP+4 form

-            12101-0001

-            

-            # invalid ZIP

-            98765-

-            ''')

-    prints::

-        # traditional ZIP code

-        12345

-        ['12345']

-

-        # ZIP+4 form

-        12101-0001

-        ['12101-0001']

-

-        # invalid ZIP

-        98765-

-             ^

-        FAIL: Expected end of text (at char 5), (line:1, col:6)

-    """

-    def __init__( self, expr, default=_optionalNotMatched ):

-        super(Optional,self).__init__( expr, savelist=False )

-        self.saveAsList = self.expr.saveAsList

-        self.defaultValue = default

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        try:

-            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )

-        except (ParseException,IndexError):

-            if self.defaultValue is not _optionalNotMatched:

-                if self.expr.resultsName:

-                    tokens = ParseResults([ self.defaultValue ])

-                    tokens[self.expr.resultsName] = self.defaultValue

-                else:

-                    tokens = [ self.defaultValue ]

-            else:

-                tokens = []

-        return loc, tokens

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "[" + _ustr(self.expr) + "]"

-

-        return self.strRepr

-

-class SkipTo(ParseElementEnhance):

-    """

-    Token for skipping over all undefined text until the matched expression is found.

-

-    Parameters:

-     - expr - target expression marking the end of the data to be skipped

-     - include - (default=C{False}) if True, the target expression is also parsed 

-          (the skipped text and target expression are returned as a 2-element list).

-     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 

-          comments) that might contain false matches to the target expression

-     - failOn - (default=C{None}) define expressions that are not allowed to be 

-          included in the skipped test; if found before the target expression is found, 

-          the SkipTo is not a match

-

-    Example::

-        report = '''

-            Outstanding Issues Report - 1 Jan 2000

-

-               # | Severity | Description                               |  Days Open

-            -----+----------+-------------------------------------------+-----------

-             101 | Critical | Intermittent system crash                 |          6

-              94 | Cosmetic | Spelling error on Login ('log|n')         |         14

-              79 | Minor    | System slow when running too many reports |         47

-            '''

-        integer = Word(nums)

-        SEP = Suppress('|')

-        # use SkipTo to simply match everything up until the next SEP

-        # - ignore quoted strings, so that a '|' character inside a quoted string does not match

-        # - parse action will call token.strip() for each matched token, i.e., the description body

-        string_data = SkipTo(SEP, ignore=quotedString)

-        string_data.setParseAction(tokenMap(str.strip))

-        ticket_expr = (integer("issue_num") + SEP 

-                      + string_data("sev") + SEP 

-                      + string_data("desc") + SEP 

-                      + integer("days_open"))

-        

-        for tkt in ticket_expr.searchString(report):

-            print tkt.dump()

-    prints::

-        ['101', 'Critical', 'Intermittent system crash', '6']

-        - days_open: 6

-        - desc: Intermittent system crash

-        - issue_num: 101

-        - sev: Critical

-        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']

-        - days_open: 14

-        - desc: Spelling error on Login ('log|n')

-        - issue_num: 94

-        - sev: Cosmetic

-        ['79', 'Minor', 'System slow when running too many reports', '47']

-        - days_open: 47

-        - desc: System slow when running too many reports

-        - issue_num: 79

-        - sev: Minor

-    """

-    def __init__( self, other, include=False, ignore=None, failOn=None ):

-        super( SkipTo, self ).__init__( other )

-        self.ignoreExpr = ignore

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-        self.includeMatch = include

-        self.asList = False

-        if isinstance(failOn, basestring):

-            self.failOn = ParserElement._literalStringClass(failOn)

-        else:

-            self.failOn = failOn

-        self.errmsg = "No match found for "+_ustr(self.expr)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        startloc = loc

-        instrlen = len(instring)

-        expr = self.expr

-        expr_parse = self.expr._parse

-        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None

-        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None

-        

-        tmploc = loc

-        while tmploc <= instrlen:

-            if self_failOn_canParseNext is not None:

-                # break if failOn expression matches

-                if self_failOn_canParseNext(instring, tmploc):

-                    break

-                    

-            if self_ignoreExpr_tryParse is not None:

-                # advance past ignore expressions

-                while 1:

-                    try:

-                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)

-                    except ParseBaseException:

-                        break

-            

-            try:

-                expr_parse(instring, tmploc, doActions=False, callPreParse=False)

-            except (ParseException, IndexError):

-                # no match, advance loc in string

-                tmploc += 1

-            else:

-                # matched skipto expr, done

-                break

-

-        else:

-            # ran off the end of the input string without matching skipto expr, fail

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        # build up return values

-        loc = tmploc

-        skiptext = instring[startloc:loc]

-        skipresult = ParseResults(skiptext)

-        

-        if self.includeMatch:

-            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)

-            skipresult += mat

-

-        return loc, skipresult

-

-class Forward(ParseElementEnhance):

-    """

-    Forward declaration of an expression to be defined later -

-    used for recursive grammars, such as algebraic infix notation.

-    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.

-

-    Note: take care when assigning to C{Forward} not to overlook precedence of operators.

-    Specifically, '|' has a lower precedence than '<<', so that::

-        fwdExpr << a | b | c

-    will actually be evaluated as::

-        (fwdExpr << a) | b | c

-    thereby leaving b and c out as parseable alternatives.  It is recommended that you

-    explicitly group the values inserted into the C{Forward}::

-        fwdExpr << (a | b | c)

-    Converting to use the '<<=' operator instead will avoid this problem.

-

-    See L{ParseResults.pprint} for an example of a recursive parser created using

-    C{Forward}.

-    """

-    def __init__( self, other=None ):

-        super(Forward,self).__init__( other, savelist=False )

-

-    def __lshift__( self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass(other)

-        self.expr = other

-        self.strRepr = None

-        self.mayIndexError = self.expr.mayIndexError

-        self.mayReturnEmpty = self.expr.mayReturnEmpty

-        self.setWhitespaceChars( self.expr.whiteChars )

-        self.skipWhitespace = self.expr.skipWhitespace

-        self.saveAsList = self.expr.saveAsList

-        self.ignoreExprs.extend(self.expr.ignoreExprs)

-        return self

-        

-    def __ilshift__(self, other):

-        return self << other

-    

-    def leaveWhitespace( self ):

-        self.skipWhitespace = False

-        return self

-

-    def streamline( self ):

-        if not self.streamlined:

-            self.streamlined = True

-            if self.expr is not None:

-                self.expr.streamline()

-        return self

-

-    def validate( self, validateTrace=[] ):

-        if self not in validateTrace:

-            tmp = validateTrace[:]+[self]

-            if self.expr is not None:

-                self.expr.validate(tmp)

-        self.checkRecursion([])

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-        return self.__class__.__name__ + ": ..."

-

-        # stubbed out for now - creates awful memory and perf issues

-        self._revertClass = self.__class__

-        self.__class__ = _ForwardNoRecurse

-        try:

-            if self.expr is not None:

-                retString = _ustr(self.expr)

-            else:

-                retString = "None"

-        finally:

-            self.__class__ = self._revertClass

-        return self.__class__.__name__ + ": " + retString

-

-    def copy(self):

-        if self.expr is not None:

-            return super(Forward,self).copy()

-        else:

-            ret = Forward()

-            ret <<= self

-            return ret

-

-class _ForwardNoRecurse(Forward):

-    def __str__( self ):

-        return "..."

-

-class TokenConverter(ParseElementEnhance):

-    """

-    Abstract subclass of C{ParseExpression}, for converting parsed results.

-    """

-    def __init__( self, expr, savelist=False ):

-        super(TokenConverter,self).__init__( expr )#, savelist )

-        self.saveAsList = False

-

-class Combine(TokenConverter):

-    """

-    Converter to concatenate all matching tokens to a single string.

-    By default, the matching patterns must also be contiguous in the input string;

-    this can be disabled by specifying C{'adjacent=False'} in the constructor.

-

-    Example::

-        real = Word(nums) + '.' + Word(nums)

-        print(real.parseString('3.1416')) # -> ['3', '.', '1416']

-        # will also erroneously match the following

-        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']

-

-        real = Combine(Word(nums) + '.' + Word(nums))

-        print(real.parseString('3.1416')) # -> ['3.1416']

-        # no match when there are internal spaces

-        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)

-    """

-    def __init__( self, expr, joinString="", adjacent=True ):

-        super(Combine,self).__init__( expr )

-        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself

-        if adjacent:

-            self.leaveWhitespace()

-        self.adjacent = adjacent

-        self.skipWhitespace = True

-        self.joinString = joinString

-        self.callPreparse = True

-

-    def ignore( self, other ):

-        if self.adjacent:

-            ParserElement.ignore(self, other)

-        else:

-            super( Combine, self).ignore( other )

-        return self

-

-    def postParse( self, instring, loc, tokenlist ):

-        retToks = tokenlist.copy()

-        del retToks[:]

-        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)

-

-        if self.resultsName and retToks.haskeys():

-            return [ retToks ]

-        else:

-            return retToks

-

-class Group(TokenConverter):

-    """

-    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.

-

-    Example::

-        ident = Word(alphas)

-        num = Word(nums)

-        term = ident | num

-        func = ident + Optional(delimitedList(term))

-        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']

-

-        func = ident + Group(Optional(delimitedList(term)))

-        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]

-    """

-    def __init__( self, expr ):

-        super(Group,self).__init__( expr )

-        self.saveAsList = True

-

-    def postParse( self, instring, loc, tokenlist ):

-        return [ tokenlist ]

-

-class Dict(TokenConverter):

-    """

-    Converter to return a repetitive expression as a list, but also as a dictionary.

-    Each element can also be referenced using the first token in the expression as its key.

-    Useful for tabular report scraping when the first column can be used as a item key.

-

-    Example::

-        data_word = Word(alphas)

-        label = data_word + FollowedBy(':')

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

-

-        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"

-        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        

-        # print attributes as plain groups

-        print(OneOrMore(attr_expr).parseString(text).dump())

-        

-        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names

-        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)

-        print(result.dump())

-        

-        # access named fields as dict entries, or output as dict

-        print(result['shape'])        

-        print(result.asDict())

-    prints::

-        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']

-

-        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]

-        - color: light blue

-        - posn: upper left

-        - shape: SQUARE

-        - texture: burlap

-        SQUARE

-        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}

-    See more examples at L{ParseResults} of accessing fields by results name.

-    """

-    def __init__( self, expr ):

-        super(Dict,self).__init__( expr )

-        self.saveAsList = True

-

-    def postParse( self, instring, loc, tokenlist ):

-        for i,tok in enumerate(tokenlist):

-            if len(tok) == 0:

-                continue

-            ikey = tok[0]

-            if isinstance(ikey,int):

-                ikey = _ustr(tok[0]).strip()

-            if len(tok)==1:

-                tokenlist[ikey] = _ParseResultsWithOffset("",i)

-            elif len(tok)==2 and not isinstance(tok[1],ParseResults):

-                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)

-            else:

-                dictvalue = tok.copy() #ParseResults(i)

-                del dictvalue[0]

-                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):

-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)

-                else:

-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)

-

-        if self.resultsName:

-            return [ tokenlist ]

-        else:

-            return tokenlist

-

-

-class Suppress(TokenConverter):

-    """

-    Converter for ignoring the results of a parsed expression.

-

-    Example::

-        source = "a, b, c,d"

-        wd = Word(alphas)

-        wd_list1 = wd + ZeroOrMore(',' + wd)

-        print(wd_list1.parseString(source))

-

-        # often, delimiters that are useful during parsing are just in the

-        # way afterward - use Suppress to keep them out of the parsed output

-        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)

-        print(wd_list2.parseString(source))

-    prints::

-        ['a', ',', 'b', ',', 'c', ',', 'd']

-        ['a', 'b', 'c', 'd']

-    (See also L{delimitedList}.)

-    """

-    def postParse( self, instring, loc, tokenlist ):

-        return []

-

-    def suppress( self ):

-        return self

-

-

-class OnlyOnce(object):

-    """

-    Wrapper for parse actions, to ensure they are only called once.

-    """

-    def __init__(self, methodCall):

-        self.callable = _trim_arity(methodCall)

-        self.called = False

-    def __call__(self,s,l,t):

-        if not self.called:

-            results = self.callable(s,l,t)

-            self.called = True

-            return results

-        raise ParseException(s,l,"")

-    def reset(self):

-        self.called = False

-

-def traceParseAction(f):

-    """

-    Decorator for debugging parse actions. 

-    

-    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}

-    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.

-

-    Example::

-        wd = Word(alphas)

-

-        @traceParseAction

-        def remove_duplicate_chars(tokens):

-            return ''.join(sorted(set(''.join(tokens))))

-

-        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)

-        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))

-    prints::

-        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))

-        <<leaving remove_duplicate_chars (ret: 'dfjkls')

-        ['dfjkls']

-    """

-    f = _trim_arity(f)

-    def z(*paArgs):

-        thisFunc = f.__name__

-        s,l,t = paArgs[-3:]

-        if len(paArgs)>3:

-            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc

-        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )

-        try:

-            ret = f(*paArgs)

-        except Exception as exc:

-            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )

-            raise

-        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) )

-        return ret

-    try:

-        z.__name__ = f.__name__

-    except AttributeError:

-        pass

-    return z

-

-#

-# global helpers

-#

-def delimitedList( expr, delim=",", combine=False ):

-    """

-    Helper to define a delimited list of expressions - the delimiter defaults to ','.

-    By default, the list elements and delimiters can have intervening whitespace, and

-    comments, but this can be overridden by passing C{combine=True} in the constructor.

-    If C{combine} is set to C{True}, the matching tokens are returned as a single token

-    string, with the delimiters included; otherwise, the matching tokens are returned

-    as a list of tokens, with the delimiters suppressed.

-

-    Example::

-        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']

-        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']

-    """

-    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."

-    if combine:

-        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)

-    else:

-        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)

-

-def countedArray( expr, intExpr=None ):

-    """

-    Helper to define a counted list of expressions.

-    This helper defines a pattern of the form::

-        integer expr expr expr...

-    where the leading integer tells how many expr expressions follow.

-    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.

-    

-    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.

-

-    Example::

-        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']

-

-        # in this parser, the leading integer value is given in binary,

-        # '10' indicating that 2 values are in the array

-        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))

-        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']

-    """

-    arrayExpr = Forward()

-    def countFieldParseAction(s,l,t):

-        n = t[0]

-        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))

-        return []

-    if intExpr is None:

-        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))

-    else:

-        intExpr = intExpr.copy()

-    intExpr.setName("arrayLen")

-    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)

-    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')

-

-def _flatten(L):

-    ret = []

-    for i in L:

-        if isinstance(i,list):

-            ret.extend(_flatten(i))

-        else:

-            ret.append(i)

-    return ret

-

-def matchPreviousLiteral(expr):

-    """

-    Helper to define an expression that is indirectly defined from

-    the tokens matched in a previous expression, that is, it looks

-    for a 'repeat' of a previous expression.  For example::

-        first = Word(nums)

-        second = matchPreviousLiteral(first)

-        matchExpr = first + ":" + second

-    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a

-    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.

-    If this is not desired, use C{matchPreviousExpr}.

-    Do I{not} use with packrat parsing enabled.

-    """

-    rep = Forward()

-    def copyTokenToRepeater(s,l,t):

-        if t:

-            if len(t) == 1:

-                rep << t[0]

-            else:

-                # flatten t tokens

-                tflat = _flatten(t.asList())

-                rep << And(Literal(tt) for tt in tflat)

-        else:

-            rep << Empty()

-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)

-    rep.setName('(prev) ' + _ustr(expr))

-    return rep

-

-def matchPreviousExpr(expr):

-    """

-    Helper to define an expression that is indirectly defined from

-    the tokens matched in a previous expression, that is, it looks

-    for a 'repeat' of a previous expression.  For example::

-        first = Word(nums)

-        second = matchPreviousExpr(first)

-        matchExpr = first + ":" + second

-    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by

-    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};

-    the expressions are evaluated first, and then compared, so

-    C{"1"} is compared with C{"10"}.

-    Do I{not} use with packrat parsing enabled.

-    """

-    rep = Forward()

-    e2 = expr.copy()

-    rep <<= e2

-    def copyTokenToRepeater(s,l,t):

-        matchTokens = _flatten(t.asList())

-        def mustMatchTheseTokens(s,l,t):

-            theseTokens = _flatten(t.asList())

-            if  theseTokens != matchTokens:

-                raise ParseException("",0,"")

-        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )

-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)

-    rep.setName('(prev) ' + _ustr(expr))

-    return rep

-

-def _escapeRegexRangeChars(s):

-    #~  escape these chars: ^-]

-    for c in r"\^-]":

-        s = s.replace(c,_bslash+c)

-    s = s.replace("\n",r"\n")

-    s = s.replace("\t",r"\t")

-    return _ustr(s)

-

-def oneOf( strs, caseless=False, useRegex=True ):

-    """

-    Helper to quickly define a set of alternative Literals, and makes sure to do

-    longest-first testing when there is a conflict, regardless of the input order,

-    but returns a C{L{MatchFirst}} for best performance.

-

-    Parameters:

-     - strs - a string of space-delimited literals, or a collection of string literals

-     - caseless - (default=C{False}) - treat all literals as caseless

-     - useRegex - (default=C{True}) - as an optimization, will generate a Regex

-          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or

-          if creating a C{Regex} raises an exception)

-

-    Example::

-        comp_oper = oneOf("< = > <= >= !=")

-        var = Word(alphas)

-        number = Word(nums)

-        term = var | number

-        comparison_expr = term + comp_oper + term

-        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))

-    prints::

-        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]

-    """

-    if caseless:

-        isequal = ( lambda a,b: a.upper() == b.upper() )

-        masks = ( lambda a,b: b.upper().startswith(a.upper()) )

-        parseElementClass = CaselessLiteral

-    else:

-        isequal = ( lambda a,b: a == b )

-        masks = ( lambda a,b: b.startswith(a) )

-        parseElementClass = Literal

-

-    symbols = []

-    if isinstance(strs,basestring):

-        symbols = strs.split()

-    elif isinstance(strs, Iterable):

-        symbols = list(strs)

-    else:

-        warnings.warn("Invalid argument to oneOf, expected string or iterable",

-                SyntaxWarning, stacklevel=2)

-    if not symbols:

-        return NoMatch()

-

-    i = 0

-    while i < len(symbols)-1:

-        cur = symbols[i]

-        for j,other in enumerate(symbols[i+1:]):

-            if ( isequal(other, cur) ):

-                del symbols[i+j+1]

-                break

-            elif ( masks(cur, other) ):

-                del symbols[i+j+1]

-                symbols.insert(i,other)

-                cur = other

-                break

-        else:

-            i += 1

-

-    if not caseless and useRegex:

-        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))

-        try:

-            if len(symbols)==len("".join(symbols)):

-                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))

-            else:

-                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))

-        except Exception:

-            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",

-                    SyntaxWarning, stacklevel=2)

-

-

-    # last resort, just use MatchFirst

-    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))

-

-def dictOf( key, value ):

-    """

-    Helper to easily and clearly define a dictionary by specifying the respective patterns

-    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens

-    in the proper order.  The key pattern can include delimiting markers or punctuation,

-    as long as they are suppressed, thereby leaving the significant key text.  The value

-    pattern can include named results, so that the C{Dict} results can include named token

-    fields.

-

-    Example::

-        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"

-        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        print(OneOrMore(attr_expr).parseString(text).dump())

-        

-        attr_label = label

-        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)

-

-        # similar to Dict, but simpler call format

-        result = dictOf(attr_label, attr_value).parseString(text)

-        print(result.dump())

-        print(result['shape'])

-        print(result.shape)  # object attribute access works too

-        print(result.asDict())

-    prints::

-        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]

-        - color: light blue

-        - posn: upper left

-        - shape: SQUARE

-        - texture: burlap

-        SQUARE

-        SQUARE

-        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}

-    """

-    return Dict( ZeroOrMore( Group ( key + value ) ) )

-

-def originalTextFor(expr, asString=True):

-    """

-    Helper to return the original, untokenized text for a given expression.  Useful to

-    restore the parsed fields of an HTML start tag into the raw tag text itself, or to

-    revert separate tokens with intervening whitespace back to the original matching

-    input text. By default, returns astring containing the original parsed text.  

-       

-    If the optional C{asString} argument is passed as C{False}, then the return value is a 

-    C{L{ParseResults}} containing any results names that were originally matched, and a 

-    single token containing the original matched text from the input string.  So if 

-    the expression passed to C{L{originalTextFor}} contains expressions with defined

-    results names, you must set C{asString} to C{False} if you want to preserve those

-    results name values.

-

-    Example::

-        src = "this is test <b> bold <i>text</i> </b> normal text "

-        for tag in ("b","i"):

-            opener,closer = makeHTMLTags(tag)

-            patt = originalTextFor(opener + SkipTo(closer) + closer)

-            print(patt.searchString(src)[0])

-    prints::

-        ['<b> bold <i>text</i> </b>']

-        ['<i>text</i>']

-    """

-    locMarker = Empty().setParseAction(lambda s,loc,t: loc)

-    endlocMarker = locMarker.copy()

-    endlocMarker.callPreparse = False

-    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")

-    if asString:

-        extractText = lambda s,l,t: s[t._original_start:t._original_end]

-    else:

-        def extractText(s,l,t):

-            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]

-    matchExpr.setParseAction(extractText)

-    matchExpr.ignoreExprs = expr.ignoreExprs

-    return matchExpr

-

-def ungroup(expr): 

-    """

-    Helper to undo pyparsing's default grouping of And expressions, even

-    if all but one are non-empty.

-    """

-    return TokenConverter(expr).setParseAction(lambda t:t[0])

-

-def locatedExpr(expr):

-    """

-    Helper to decorate a returned token with its starting and ending locations in the input string.

-    This helper adds the following results names:

-     - locn_start = location where matched expression begins

-     - locn_end = location where matched expression ends

-     - value = the actual parsed results

-

-    Be careful if the input text contains C{<TAB>} characters, you may want to call

-    C{L{ParserElement.parseWithTabs}}

-

-    Example::

-        wd = Word(alphas)

-        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):

-            print(match)

-    prints::

-        [[0, 'ljsdf', 5]]

-        [[8, 'lksdjjf', 15]]

-        [[18, 'lkkjj', 23]]

-    """

-    locator = Empty().setParseAction(lambda s,l,t: l)

-    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))

-

-

-# convenience constants for positional expressions

-empty       = Empty().setName("empty")

-lineStart   = LineStart().setName("lineStart")

-lineEnd     = LineEnd().setName("lineEnd")

-stringStart = StringStart().setName("stringStart")

-stringEnd   = StringEnd().setName("stringEnd")

-

-_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])

-_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))

-_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))

-_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)

-_charRange = Group(_singleChar + Suppress("-") + _singleChar)

-_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"

-

-def srange(s):

-    r"""

-    Helper to easily define string ranges for use in Word construction.  Borrows

-    syntax from regexp '[]' string range definitions::

-        srange("[0-9]")   -> "0123456789"

-        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"

-        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"

-    The input string must be enclosed in []'s, and the returned string is the expanded

-    character set joined into a single string.

-    The values enclosed in the []'s may be:

-     - a single character

-     - an escaped character with a leading backslash (such as C{\-} or C{\]})

-     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 

-         (C{\0x##} is also supported for backwards compatibility) 

-     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)

-     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)

-     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)

-    """

-    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))

-    try:

-        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)

-    except Exception:

-        return ""

-

-def matchOnlyAtCol(n):

-    """

-    Helper method for defining parse actions that require matching at a specific

-    column in the input text.

-    """

-    def verifyCol(strg,locn,toks):

-        if col(locn,strg) != n:

-            raise ParseException(strg,locn,"matched token not at column %d" % n)

-    return verifyCol

-

-def replaceWith(replStr):

-    """

-    Helper method for common parse actions that simply return a literal value.  Especially

-    useful when used with C{L{transformString<ParserElement.transformString>}()}.

-

-    Example::

-        num = Word(nums).setParseAction(lambda toks: int(toks[0]))

-        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))

-        term = na | num

-        

-        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]

-    """

-    return lambda s,l,t: [replStr]

-

-def removeQuotes(s,l,t):

-    """

-    Helper parse action for removing quotation marks from parsed quoted strings.

-

-    Example::

-        # by default, quotation marks are included in parsed results

-        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]

-

-        # use removeQuotes to strip quotation marks from parsed results

-        quotedString.setParseAction(removeQuotes)

-        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]

-    """

-    return t[0][1:-1]

-

-def tokenMap(func, *args):

-    """

-    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 

-    args are passed, they are forwarded to the given function as additional arguments after

-    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the

-    parsed data to an integer using base 16.

-

-    Example (compare the last to example in L{ParserElement.transformString}::

-        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))

-        hex_ints.runTests('''

-            00 11 22 aa FF 0a 0d 1a

-            ''')

-        

-        upperword = Word(alphas).setParseAction(tokenMap(str.upper))

-        OneOrMore(upperword).runTests('''

-            my kingdom for a horse

-            ''')

-

-        wd = Word(alphas).setParseAction(tokenMap(str.title))

-        OneOrMore(wd).setParseAction(' '.join).runTests('''

-            now is the winter of our discontent made glorious summer by this sun of york

-            ''')

-    prints::

-        00 11 22 aa FF 0a 0d 1a

-        [0, 17, 34, 170, 255, 10, 13, 26]

-

-        my kingdom for a horse

-        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']

-

-        now is the winter of our discontent made glorious summer by this sun of york

-        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']

-    """

-    def pa(s,l,t):

-        return [func(tokn, *args) for tokn in t]

-

-    try:

-        func_name = getattr(func, '__name__', 

-                            getattr(func, '__class__').__name__)

-    except Exception:

-        func_name = str(func)

-    pa.__name__ = func_name

-

-    return pa

-

-upcaseTokens = tokenMap(lambda t: _ustr(t).upper())

-"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""

-

-downcaseTokens = tokenMap(lambda t: _ustr(t).lower())

-"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""

-    

-def _makeTags(tagStr, xml):

-    """Internal helper to construct opening and closing tag expressions, given a tag name"""

-    if isinstance(tagStr,basestring):

-        resname = tagStr

-        tagStr = Keyword(tagStr, caseless=not xml)

-    else:

-        resname = tagStr.name

-

-    tagAttrName = Word(alphas,alphanums+"_-:")

-    if (xml):

-        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )

-        openTag = Suppress("<") + tagStr("tag") + \

-                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \

-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")

-    else:

-        printablesLessRAbrack = "".join(c for c in printables if c not in ">")

-        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)

-        openTag = Suppress("<") + tagStr("tag") + \

-                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \

-                Optional( Suppress("=") + tagAttrValue ) ))) + \

-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")

-    closeTag = Combine(_L("</") + tagStr + ">")

-

-    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)

-    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname)

-    openTag.tag = resname

-    closeTag.tag = resname

-    return openTag, closeTag

-

-def makeHTMLTags(tagStr):

-    """

-    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches

-    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.

-

-    Example::

-        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'

-        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple

-        a,a_end = makeHTMLTags("A")

-        link_expr = a + SkipTo(a_end)("link_text") + a_end

-        

-        for link in link_expr.searchString(text):

-            # attributes in the <A> tag (like "href" shown here) are also accessible as named results

-            print(link.link_text, '->', link.href)

-    prints::

-        pyparsing -> http://pyparsing.wikispaces.com

-    """

-    return _makeTags( tagStr, False )

-

-def makeXMLTags(tagStr):

-    """

-    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches

-    tags only in the given upper/lower case.

-

-    Example: similar to L{makeHTMLTags}

-    """

-    return _makeTags( tagStr, True )

-

-def withAttribute(*args,**attrDict):

-    """

-    Helper to create a validating parse action to be used with start tags created

-    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag

-    with a required attribute value, to avoid false matches on common tags such as

-    C{<TD>} or C{<DIV>}.

-

-    Call C{withAttribute} with a series of attribute names and values. Specify the list

-    of filter attributes names and values as:

-     - keyword arguments, as in C{(align="right")}, or

-     - as an explicit dict with C{**} operator, when an attribute name is also a Python

-          reserved word, as in C{**{"class":"Customer", "align":"right"}}

-     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )

-    For attribute names with a namespace prefix, you must use the second form.  Attribute

-    names are matched insensitive to upper/lower case.

-       

-    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.

-

-    To verify that the attribute exists, but without specifying a value, pass

-    C{withAttribute.ANY_VALUE} as the value.

-

-    Example::

-        html = '''

-            <div>

-            Some text

-            <div type="grid">1 4 0 1 0</div>

-            <div type="graph">1,3 2,3 1,1</div>

-            <div>this has no type</div>

-            </div>

-                

-        '''

-        div,div_end = makeHTMLTags("div")

-

-        # only match div tag having a type attribute with value "grid"

-        div_grid = div().setParseAction(withAttribute(type="grid"))

-        grid_expr = div_grid + SkipTo(div | div_end)("body")

-        for grid_header in grid_expr.searchString(html):

-            print(grid_header.body)

-        

-        # construct a match with any div tag having a type attribute, regardless of the value

-        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))

-        div_expr = div_any_type + SkipTo(div | div_end)("body")

-        for div_header in div_expr.searchString(html):

-            print(div_header.body)

-    prints::

-        1 4 0 1 0

-

-        1 4 0 1 0

-        1,3 2,3 1,1

-    """

-    if args:

-        attrs = args[:]

-    else:

-        attrs = attrDict.items()

-    attrs = [(k,v) for k,v in attrs]

-    def pa(s,l,tokens):

-        for attrName,attrValue in attrs:

-            if attrName not in tokens:

-                raise ParseException(s,l,"no matching attribute " + attrName)

-            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:

-                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %

-                                            (attrName, tokens[attrName], attrValue))

-    return pa

-withAttribute.ANY_VALUE = object()

-

-def withClass(classname, namespace=''):

-    """

-    Simplified version of C{L{withAttribute}} when matching on a div class - made

-    difficult because C{class} is a reserved word in Python.

-

-    Example::

-        html = '''

-            <div>

-            Some text

-            <div class="grid">1 4 0 1 0</div>

-            <div class="graph">1,3 2,3 1,1</div>

-            <div>this &lt;div&gt; has no class</div>

-            </div>

-                

-        '''

-        div,div_end = makeHTMLTags("div")

-        div_grid = div().setParseAction(withClass("grid"))

-        

-        grid_expr = div_grid + SkipTo(div | div_end)("body")

-        for grid_header in grid_expr.searchString(html):

-            print(grid_header.body)

-        

-        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))

-        div_expr = div_any_type + SkipTo(div | div_end)("body")

-        for div_header in div_expr.searchString(html):

-            print(div_header.body)

-    prints::

-        1 4 0 1 0

-

-        1 4 0 1 0

-        1,3 2,3 1,1

-    """

-    classattr = "%s:class" % namespace if namespace else "class"

-    return withAttribute(**{classattr : classname})        

-

-opAssoc = _Constants()

-opAssoc.LEFT = object()

-opAssoc.RIGHT = object()

-

-def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):

-    """

-    Helper method for constructing grammars of expressions made up of

-    operators working in a precedence hierarchy.  Operators may be unary or

-    binary, left- or right-associative.  Parse actions can also be attached

-    to operator expressions. The generated parser will also recognize the use 

-    of parentheses to override operator precedences (see example below).

-    

-    Note: if you define a deep operator list, you may see performance issues

-    when using infixNotation. See L{ParserElement.enablePackrat} for a

-    mechanism to potentially improve your parser performance.

-

-    Parameters:

-     - baseExpr - expression representing the most basic element for the nested

-     - opList - list of tuples, one for each operator precedence level in the

-      expression grammar; each tuple is of the form

-      (opExpr, numTerms, rightLeftAssoc, parseAction), where:

-       - opExpr is the pyparsing expression for the operator;

-          may also be a string, which will be converted to a Literal;

-          if numTerms is 3, opExpr is a tuple of two expressions, for the

-          two operators separating the 3 terms

-       - numTerms is the number of terms for this operator (must

-          be 1, 2, or 3)

-       - rightLeftAssoc is the indicator whether the operator is

-          right or left associative, using the pyparsing-defined

-          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.

-       - parseAction is the parse action to be associated with

-          expressions matching this operator expression (the

-          parse action tuple member may be omitted); if the parse action

-          is passed a tuple or list of functions, this is equivalent to

-          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})

-     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})

-     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})

-

-    Example::

-        # simple example of four-function arithmetic with ints and variable names

-        integer = pyparsing_common.signed_integer

-        varname = pyparsing_common.identifier 

-        

-        arith_expr = infixNotation(integer | varname,

-            [

-            ('-', 1, opAssoc.RIGHT),

-            (oneOf('* /'), 2, opAssoc.LEFT),

-            (oneOf('+ -'), 2, opAssoc.LEFT),

-            ])

-        

-        arith_expr.runTests('''

-            5+3*6

-            (5+3)*6

-            -2--11

-            ''', fullDump=False)

-    prints::

-        5+3*6

-        [[5, '+', [3, '*', 6]]]

-

-        (5+3)*6

-        [[[5, '+', 3], '*', 6]]

-

-        -2--11

-        [[['-', 2], '-', ['-', 11]]]

-    """

-    ret = Forward()

-    lastExpr = baseExpr | ( lpar + ret + rpar )

-    for i,operDef in enumerate(opList):

-        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]

-        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr

-        if arity == 3:

-            if opExpr is None or len(opExpr) != 2:

-                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")

-            opExpr1, opExpr2 = opExpr

-        thisExpr = Forward().setName(termName)

-        if rightLeftAssoc == opAssoc.LEFT:

-            if arity == 1:

-                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )

-            elif arity == 2:

-                if opExpr is not None:

-                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )

-                else:

-                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )

-            elif arity == 3:

-                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \

-                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )

-            else:

-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")

-        elif rightLeftAssoc == opAssoc.RIGHT:

-            if arity == 1:

-                # try to avoid LR with this extra test

-                if not isinstance(opExpr, Optional):

-                    opExpr = Optional(opExpr)

-                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )

-            elif arity == 2:

-                if opExpr is not None:

-                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )

-                else:

-                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )

-            elif arity == 3:

-                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \

-                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )

-            else:

-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")

-        else:

-            raise ValueError("operator must indicate right or left associativity")

-        if pa:

-            if isinstance(pa, (tuple, list)):

-                matchExpr.setParseAction(*pa)

-            else:

-                matchExpr.setParseAction(pa)

-        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )

-        lastExpr = thisExpr

-    ret <<= lastExpr

-    return ret

-

-operatorPrecedence = infixNotation

-"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""

-

-dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")

-sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")

-quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|

-                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")

-unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")

-

-def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):

-    """

-    Helper method for defining nested lists enclosed in opening and closing

-    delimiters ("(" and ")" are the default).

-

-    Parameters:

-     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression

-     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression

-     - content - expression for items within the nested lists (default=C{None})

-     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})

-

-    If an expression is not provided for the content argument, the nested

-    expression will capture all whitespace-delimited content between delimiters

-    as a list of separate values.

-

-    Use the C{ignoreExpr} argument to define expressions that may contain

-    opening or closing characters that should not be treated as opening

-    or closing characters for nesting, such as quotedString or a comment

-    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.

-    The default is L{quotedString}, but if no expressions are to be ignored,

-    then pass C{None} for this argument.

-

-    Example::

-        data_type = oneOf("void int short long char float double")

-        decl_data_type = Combine(data_type + Optional(Word('*')))

-        ident = Word(alphas+'_', alphanums+'_')

-        number = pyparsing_common.number

-        arg = Group(decl_data_type + ident)

-        LPAR,RPAR = map(Suppress, "()")

-

-        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))

-

-        c_function = (decl_data_type("type") 

-                      + ident("name")

-                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 

-                      + code_body("body"))

-        c_function.ignore(cStyleComment)

-        

-        source_code = '''

-            int is_odd(int x) { 

-                return (x%2); 

-            }

-                

-            int dec_to_hex(char hchar) { 

-                if (hchar >= '0' && hchar <= '9') { 

-                    return (ord(hchar)-ord('0')); 

-                } else { 

-                    return (10+ord(hchar)-ord('A'));

-                } 

-            }

-        '''

-        for func in c_function.searchString(source_code):

-            print("%(name)s (%(type)s) args: %(args)s" % func)

-

-    prints::

-        is_odd (int) args: [['int', 'x']]

-        dec_to_hex (int) args: [['char', 'hchar']]

-    """

-    if opener == closer:

-        raise ValueError("opening and closing strings cannot be the same")

-    if content is None:

-        if isinstance(opener,basestring) and isinstance(closer,basestring):

-            if len(opener) == 1 and len(closer)==1:

-                if ignoreExpr is not None:

-                    content = (Combine(OneOrMore(~ignoreExpr +

-                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))

-                                ).setParseAction(lambda t:t[0].strip()))

-                else:

-                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS

-                                ).setParseAction(lambda t:t[0].strip()))

-            else:

-                if ignoreExpr is not None:

-                    content = (Combine(OneOrMore(~ignoreExpr + 

-                                    ~Literal(opener) + ~Literal(closer) +

-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))

-                                ).setParseAction(lambda t:t[0].strip()))

-                else:

-                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +

-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))

-                                ).setParseAction(lambda t:t[0].strip()))

-        else:

-            raise ValueError("opening and closing arguments must be strings if no content expression is given")

-    ret = Forward()

-    if ignoreExpr is not None:

-        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )

-    else:

-        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )

-    ret.setName('nested %s%s expression' % (opener,closer))

-    return ret

-

-def indentedBlock(blockStatementExpr, indentStack, indent=True):

-    """

-    Helper method for defining space-delimited indentation blocks, such as

-    those used to define block statements in Python source code.

-

-    Parameters:

-     - blockStatementExpr - expression defining syntax of statement that

-            is repeated within the indented block

-     - indentStack - list created by caller to manage indentation stack

-            (multiple statementWithIndentedBlock expressions within a single grammar

-            should share a common indentStack)

-     - indent - boolean indicating whether block must be indented beyond the

-            the current level; set to False for block of left-most statements

-            (default=C{True})

-

-    A valid block must contain at least one C{blockStatement}.

-

-    Example::

-        data = '''

-        def A(z):

-          A1

-          B = 100

-          G = A2

-          A2

-          A3

-        B

-        def BB(a,b,c):

-          BB1

-          def BBA():

-            bba1

-            bba2

-            bba3

-        C

-        D

-        def spam(x,y):

-             def eggs(z):

-                 pass

-        '''

-

-

-        indentStack = [1]

-        stmt = Forward()

-

-        identifier = Word(alphas, alphanums)

-        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")

-        func_body = indentedBlock(stmt, indentStack)

-        funcDef = Group( funcDecl + func_body )

-

-        rvalue = Forward()

-        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")

-        rvalue << (funcCall | identifier | Word(nums))

-        assignment = Group(identifier + "=" + rvalue)

-        stmt << ( funcDef | assignment | identifier )

-

-        module_body = OneOrMore(stmt)

-

-        parseTree = module_body.parseString(data)

-        parseTree.pprint()

-    prints::

-        [['def',

-          'A',

-          ['(', 'z', ')'],

-          ':',

-          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],

-         'B',

-         ['def',

-          'BB',

-          ['(', 'a', 'b', 'c', ')'],

-          ':',

-          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],

-         'C',

-         'D',

-         ['def',

-          'spam',

-          ['(', 'x', 'y', ')'],

-          ':',

-          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 

-    """

-    def checkPeerIndent(s,l,t):

-        if l >= len(s): return

-        curCol = col(l,s)

-        if curCol != indentStack[-1]:

-            if curCol > indentStack[-1]:

-                raise ParseFatalException(s,l,"illegal nesting")

-            raise ParseException(s,l,"not a peer entry")

-

-    def checkSubIndent(s,l,t):

-        curCol = col(l,s)

-        if curCol > indentStack[-1]:

-            indentStack.append( curCol )

-        else:

-            raise ParseException(s,l,"not a subentry")

-

-    def checkUnindent(s,l,t):

-        if l >= len(s): return

-        curCol = col(l,s)

-        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):

-            raise ParseException(s,l,"not an unindent")

-        indentStack.pop()

-

-    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())

-    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')

-    PEER   = Empty().setParseAction(checkPeerIndent).setName('')

-    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')

-    if indent:

-        smExpr = Group( Optional(NL) +

-            #~ FollowedBy(blockStatementExpr) +

-            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)

-    else:

-        smExpr = Group( Optional(NL) +

-            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )

-    blockStatementExpr.ignore(_bslash + LineEnd())

-    return smExpr.setName('indented block')

-

-alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")

-punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")

-

-anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))

-_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))

-commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")

-def replaceHTMLEntity(t):

-    """Helper parser action to replace common HTML entities with their special characters"""

-    return _htmlEntityMap.get(t.entity)

-

-# it's easy to get these comment structures wrong - they're very common, so may as well make them available

-cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")

-"Comment of the form C{/* ... */}"

-

-htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment")

-"Comment of the form C{<!-- ... -->}"

-

-restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")

-dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")

-"Comment of the form C{// ... (to end of line)}"

-

-cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")

-"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"

-

-javaStyleComment = cppStyleComment

-"Same as C{L{cppStyleComment}}"

-

-pythonStyleComment = Regex(r"#.*").setName("Python style comment")

-"Comment of the form C{# ... (to end of line)}"

-

-_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +

-                                  Optional( Word(" \t") +

-                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")

-commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")

-"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.

-   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""

-

-# some other useful expressions - using lower-case class name since we are really using this as a namespace

-class pyparsing_common:

-    """

-    Here are some common low-level expressions that may be useful in jump-starting parser development:

-     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>})

-     - common L{programming identifiers<identifier>}

-     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>})

-     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>}

-     - L{UUID<uuid>}

-     - L{comma-separated list<comma_separated_list>}

-    Parse actions:

-     - C{L{convertToInteger}}

-     - C{L{convertToFloat}}

-     - C{L{convertToDate}}

-     - C{L{convertToDatetime}}

-     - C{L{stripHTMLTags}}

-     - C{L{upcaseTokens}}

-     - C{L{downcaseTokens}}

-

-    Example::

-        pyparsing_common.number.runTests('''

-            # any int or real number, returned as the appropriate type

-            100

-            -100

-            +100

-            3.14159

-            6.02e23

-            1e-12

-            ''')

-

-        pyparsing_common.fnumber.runTests('''

-            # any int or real number, returned as float

-            100

-            -100

-            +100

-            3.14159

-            6.02e23

-            1e-12

-            ''')

-

-        pyparsing_common.hex_integer.runTests('''

-            # hex numbers

-            100

-            FF

-            ''')

-

-        pyparsing_common.fraction.runTests('''

-            # fractions

-            1/2

-            -3/4

-            ''')

-

-        pyparsing_common.mixed_integer.runTests('''

-            # mixed fractions

-            1

-            1/2

-            -3/4

-            1-3/4

-            ''')

-

-        import uuid

-        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))

-        pyparsing_common.uuid.runTests('''

-            # uuid

-            12345678-1234-5678-1234-567812345678

-            ''')

-    prints::

-        # any int or real number, returned as the appropriate type

-        100

-        [100]

-

-        -100

-        [-100]

-

-        +100

-        [100]

-

-        3.14159

-        [3.14159]

-

-        6.02e23

-        [6.02e+23]

-

-        1e-12

-        [1e-12]

-

-        # any int or real number, returned as float

-        100

-        [100.0]

-

-        -100

-        [-100.0]

-

-        +100

-        [100.0]

-

-        3.14159

-        [3.14159]

-

-        6.02e23

-        [6.02e+23]

-

-        1e-12

-        [1e-12]

-

-        # hex numbers

-        100

-        [256]

-

-        FF

-        [255]

-

-        # fractions

-        1/2

-        [0.5]

-

-        -3/4

-        [-0.75]

-

-        # mixed fractions

-        1

-        [1]

-

-        1/2

-        [0.5]

-

-        -3/4

-        [-0.75]

-

-        1-3/4

-        [1.75]

-

-        # uuid

-        12345678-1234-5678-1234-567812345678

-        [UUID('12345678-1234-5678-1234-567812345678')]

-    """

-

-    convertToInteger = tokenMap(int)

-    """

-    Parse action for converting parsed integers to Python int

-    """

-

-    convertToFloat = tokenMap(float)

-    """

-    Parse action for converting parsed numbers to Python float

-    """

-

-    integer = Word(nums).setName("integer").setParseAction(convertToInteger)

-    """expression that parses an unsigned integer, returns an int"""

-

-    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))

-    """expression that parses a hexadecimal integer, returns an int"""

-

-    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)

-    """expression that parses an integer with optional leading sign, returns an int"""

-

-    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")

-    """fractional expression of an integer divided by an integer, returns a float"""

-    fraction.addParseAction(lambda t: t[0]/t[-1])

-

-    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")

-    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""

-    mixed_integer.addParseAction(sum)

-

-    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)

-    """expression that parses a floating point number and returns a float"""

-

-    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)

-    """expression that parses a floating point number with optional scientific notation and returns a float"""

-

-    # streamlining this expression makes the docs nicer-looking

-    number = (sci_real | real | signed_integer).streamline()

-    """any numeric expression, returns the corresponding Python type"""

-

-    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)

-    """any int or real number, returned as float"""

-    

-    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")

-    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""

-    

-    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")

-    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"

-

-    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")

-    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")

-    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")

-    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)

-    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")

-    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")

-    "IPv6 address (long, short, or mixed form)"

-    

-    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")

-    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"

-

-    @staticmethod

-    def convertToDate(fmt="%Y-%m-%d"):

-        """

-        Helper to create a parse action for converting parsed date string to Python datetime.date

-

-        Params -

-         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})

-

-        Example::

-            date_expr = pyparsing_common.iso8601_date.copy()

-            date_expr.setParseAction(pyparsing_common.convertToDate())

-            print(date_expr.parseString("1999-12-31"))

-        prints::

-            [datetime.date(1999, 12, 31)]

-        """

-        def cvt_fn(s,l,t):

-            try:

-                return datetime.strptime(t[0], fmt).date()

-            except ValueError as ve:

-                raise ParseException(s, l, str(ve))

-        return cvt_fn

-

-    @staticmethod

-    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):

-        """

-        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime

-

-        Params -

-         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})

-

-        Example::

-            dt_expr = pyparsing_common.iso8601_datetime.copy()

-            dt_expr.setParseAction(pyparsing_common.convertToDatetime())

-            print(dt_expr.parseString("1999-12-31T23:59:59.999"))

-        prints::

-            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]

-        """

-        def cvt_fn(s,l,t):

-            try:

-                return datetime.strptime(t[0], fmt)

-            except ValueError as ve:

-                raise ParseException(s, l, str(ve))

-        return cvt_fn

-

-    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date")

-    "ISO8601 date (C{yyyy-mm-dd})"

-

-    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")

-    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"

-

-    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")

-    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"

-

-    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()

-    @staticmethod

-    def stripHTMLTags(s, l, tokens):

-        """

-        Parse action to remove HTML tags from web page HTML source

-

-        Example::

-            # strip HTML links from normal text 

-            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'

-            td,td_end = makeHTMLTags("TD")

-            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end

-            

-            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'

-        """

-        return pyparsing_common._html_stripper.transformString(tokens[0])

-

-    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 

-                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")

-    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")

-    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""

-

-    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))

-    """Parse action to convert tokens to upper case."""

-

-    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))

-    """Parse action to convert tokens to lower case."""

-

-

-if __name__ == "__main__":

-

-    selectToken    = CaselessLiteral("select")

-    fromToken      = CaselessLiteral("from")

-

-    ident          = Word(alphas, alphanums + "_$")

-

-    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)

-    columnNameList = Group(delimitedList(columnName)).setName("columns")

-    columnSpec     = ('*' | columnNameList)

-

-    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)

-    tableNameList  = Group(delimitedList(tableName)).setName("tables")

-    

-    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")

-

-    # demo runTests method, including embedded comments in test string

-    simpleSQL.runTests("""

-        # '*' as column list and dotted table name

-        select * from SYS.XYZZY

-

-        # caseless match on "SELECT", and casts back to "select"

-        SELECT * from XYZZY, ABC

-

-        # list of column names, and mixed case SELECT keyword

-        Select AA,BB,CC from Sys.dual

-

-        # multiple tables

-        Select A, B, C from Sys.dual, Table2

-

-        # invalid SELECT keyword - should fail

-        Xelect A, B, C from Sys.dual

-

-        # incomplete command - should fail

-        Select

-

-        # invalid column name - should fail

-        Select ^^^ frox Sys.dual

-

-        """)

-

-    pyparsing_common.number.runTests("""

-        100

-        -100

-        +100

-        3.14159

-        6.02e23

-        1e-12

-        """)

-

-    # any int or real number, returned as float

-    pyparsing_common.fnumber.runTests("""

-        100

-        -100

-        +100

-        3.14159

-        6.02e23

-        1e-12

-        """)

-

-    pyparsing_common.hex_integer.runTests("""

-        100

-        FF

-        """)

-

-    import uuid

-    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))

-    pyparsing_common.uuid.runTests("""

-        12345678-1234-5678-1234-567812345678

-        """)

+# module pyparsing.py 
+# 
+# Copyright (c) 2003-2018  Paul T. McGuire 
+# 
+# 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. 
+# 
+ 
+__doc__ = \ 
+""" 
+pyparsing module - Classes and methods to define and execute parsing grammars 
+============================================================================= 
+ 
+The pyparsing module is an alternative approach to creating and executing simple grammars, 
+vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you 
+don't need to learn a new syntax for defining grammars or matching expressions - the parsing module 
+provides a library of classes that you use to construct the grammar directly in Python. 
+ 
+Here is a program to parse "Hello, World!" (or any greeting of the form  
+C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements  
+(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to 
+L{Literal} expressions):: 
+ 
+    from pyparsing import Word, alphas 
+ 
+    # define grammar of a greeting 
+    greet = Word(alphas) + "," + Word(alphas) + "!" 
+ 
+    hello = "Hello, World!" 
+    print (hello, "->", greet.parseString(hello)) 
+ 
+The program outputs the following:: 
+ 
+    Hello, World! -> ['Hello', ',', 'World', '!'] 
+ 
+The Python representation of the grammar is quite readable, owing to the self-explanatory 
+class names, and the use of '+', '|' and '^' operators. 
+ 
+The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an 
+object with named attributes. 
+ 
+The pyparsing module handles some of the problems that are typically vexing when writing text parsers: 
+ - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.) 
+ - quoted strings 
+ - embedded comments 
+ 
+ 
+Getting Started - 
+----------------- 
+Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing 
+classes inherit from. Use the docstrings for examples of how to: 
+ - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes 
+ - construct character word-group expressions using the L{Word} class 
+ - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes 
+ - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones 
+ - associate names with your parsed results using L{ParserElement.setResultsName} 
+ - find some helpful expression short-cuts like L{delimitedList} and L{oneOf} 
+ - find more useful common expressions in the L{pyparsing_common} namespace class 
+""" 
+ 
+__version__ = "2.2.1" 
+__versionTime__ = "18 Sep 2018 00:49 UTC" 
+__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>" 
+ 
+import string 
+from weakref import ref as wkref 
+import copy 
+import sys 
+import warnings 
+import re 
+import sre_constants 
+import collections 
+import pprint 
+import traceback 
+import types 
+from datetime import datetime 
+ 
+try: 
+    from _thread import RLock 
+except ImportError: 
+    from threading import RLock 
+ 
+try: 
+    # Python 3 
+    from collections.abc import Iterable 
+    from collections.abc import MutableMapping 
+except ImportError: 
+    # Python 2.7 
+    from collections import Iterable 
+    from collections import MutableMapping 
+ 
+try: 
+    from collections import OrderedDict as _OrderedDict 
+except ImportError: 
+    try: 
+        from ordereddict import OrderedDict as _OrderedDict 
+    except ImportError: 
+        _OrderedDict = None 
+ 
+#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) ) 
+ 
+__all__ = [ 
+'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty', 
+'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal', 
+'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or', 
+'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException', 
+'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException', 
+'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter',  
+'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore', 
+'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col', 
+'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString', 
+'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums', 
+'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno', 
+'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral', 
+'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables', 
+'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity',  
+'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd', 
+'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute', 
+'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass', 
+'CloseMatch', 'tokenMap', 'pyparsing_common', 
+] 
+ 
+system_version = tuple(sys.version_info)[:3] 
+PY_3 = system_version[0] == 3 
+if PY_3: 
+    _MAX_INT = sys.maxsize 
+    basestring = str 
+    unichr = chr 
+    _ustr = str 
+ 
+    # build list of single arg builtins, that can be used as parse actions 
+    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max] 
+ 
+else: 
+    _MAX_INT = sys.maxint 
+    range = xrange 
+ 
+    def _ustr(obj): 
+        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries 
+           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It 
+           then < returns the unicode object | encodes it with the default encoding | ... >. 
+        """ 
+        if isinstance(obj,unicode): 
+            return obj 
+ 
+        try: 
+            # If this works, then _ustr(obj) has the same behaviour as str(obj), so 
+            # it won't break any existing code. 
+            return str(obj) 
+ 
+        except UnicodeEncodeError: 
+            # Else encode it 
+            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace') 
+            xmlcharref = Regex(r'&#\d+;') 
+            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:]) 
+            return xmlcharref.transformString(ret) 
+ 
+    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions 
+    singleArgBuiltins = [] 
+    import __builtin__ 
+    for fname in "sum len sorted reversed list tuple set any all min max".split(): 
+        try: 
+            singleArgBuiltins.append(getattr(__builtin__,fname)) 
+        except AttributeError: 
+            continue 
+             
+_generatorType = type((y for y in range(1))) 
+  
+def _xml_escape(data): 
+    """Escape &, <, >, ", ', etc. in a string of data.""" 
+ 
+    # ampersand must be replaced first 
+    from_symbols = '&><"\'' 
+    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split()) 
+    for from_,to_ in zip(from_symbols, to_symbols): 
+        data = data.replace(from_, to_) 
+    return data 
+ 
+class _Constants(object): 
+    pass 
+ 
+alphas     = string.ascii_uppercase + string.ascii_lowercase 
+nums       = "0123456789" 
+hexnums    = nums + "ABCDEFabcdef" 
+alphanums  = alphas + nums 
+_bslash    = chr(92) 
+printables = "".join(c for c in string.printable if c not in string.whitespace) 
+ 
+class ParseBaseException(Exception): 
+    """base exception class for all parsing runtime exceptions""" 
+    # Performance tuning: we construct a *lot* of these, so keep this 
+    # constructor as small and fast as possible 
+    def __init__( self, pstr, loc=0, msg=None, elem=None ): 
+        self.loc = loc 
+        if msg is None: 
+            self.msg = pstr 
+            self.pstr = "" 
+        else: 
+            self.msg = msg 
+            self.pstr = pstr 
+        self.parserElement = elem 
+        self.args = (pstr, loc, msg) 
+ 
+    @classmethod 
+    def _from_exception(cls, pe): 
+        """ 
+        internal factory method to simplify creating one type of ParseException  
+        from another - avoids having __init__ signature conflicts among subclasses 
+        """ 
+        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement) 
+ 
+    def __getattr__( self, aname ): 
+        """supported attributes by name are: 
+            - lineno - returns the line number of the exception text 
+            - col - returns the column number of the exception text 
+            - line - returns the line containing the exception text 
+        """ 
+        if( aname == "lineno" ): 
+            return lineno( self.loc, self.pstr ) 
+        elif( aname in ("col", "column") ): 
+            return col( self.loc, self.pstr ) 
+        elif( aname == "line" ): 
+            return line( self.loc, self.pstr ) 
+        else: 
+            raise AttributeError(aname) 
+ 
+    def __str__( self ): 
+        return "%s (at char %d), (line:%d, col:%d)" % \ 
+                ( self.msg, self.loc, self.lineno, self.column ) 
+    def __repr__( self ): 
+        return _ustr(self) 
+    def markInputline( self, markerString = ">!<" ): 
+        """Extracts the exception line from the input string, and marks 
+           the location of the exception with a special symbol. 
+        """ 
+        line_str = self.line 
+        line_column = self.column - 1 
+        if markerString: 
+            line_str = "".join((line_str[:line_column], 
+                                markerString, line_str[line_column:])) 
+        return line_str.strip() 
+    def __dir__(self): 
+        return "lineno col line".split() + dir(type(self)) 
+ 
+class ParseException(ParseBaseException): 
+    """ 
+    Exception thrown when parse expressions don't match class; 
+    supported attributes by name are: 
+     - lineno - returns the line number of the exception text 
+     - col - returns the column number of the exception text 
+     - line - returns the line containing the exception text 
+         
+    Example:: 
+        try: 
+            Word(nums).setName("integer").parseString("ABC") 
+        except ParseException as pe: 
+            print(pe) 
+            print("column: {}".format(pe.col)) 
+             
+    prints:: 
+       Expected integer (at char 0), (line:1, col:1) 
+        column: 1 
+    """ 
+    pass 
+ 
+class ParseFatalException(ParseBaseException): 
+    """user-throwable exception thrown when inconsistent parse content 
+       is found; stops all parsing immediately""" 
+    pass 
+ 
+class ParseSyntaxException(ParseFatalException): 
+    """just like L{ParseFatalException}, but thrown internally when an 
+       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop  
+       immediately because an unbacktrackable syntax error has been found""" 
+    pass 
+ 
+#~ class ReparseException(ParseBaseException): 
+    #~ """Experimental class - parse actions can raise this exception to cause 
+       #~ pyparsing to reparse the input string: 
+        #~ - with a modified input string, and/or 
+        #~ - with a modified start location 
+       #~ Set the values of the ReparseException in the constructor, and raise the 
+       #~ exception in a parse action to cause pyparsing to use the new string/location. 
+       #~ Setting the values as None causes no change to be made. 
+       #~ """ 
+    #~ def __init_( self, newstring, restartLoc ): 
+        #~ self.newParseText = newstring 
+        #~ self.reparseLoc = restartLoc 
+ 
+class RecursiveGrammarException(Exception): 
+    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive""" 
+    def __init__( self, parseElementList ): 
+        self.parseElementTrace = parseElementList 
+ 
+    def __str__( self ): 
+        return "RecursiveGrammarException: %s" % self.parseElementTrace 
+ 
+class _ParseResultsWithOffset(object): 
+    def __init__(self,p1,p2): 
+        self.tup = (p1,p2) 
+    def __getitem__(self,i): 
+        return self.tup[i] 
+    def __repr__(self): 
+        return repr(self.tup[0]) 
+    def setOffset(self,i): 
+        self.tup = (self.tup[0],i) 
+ 
+class ParseResults(object): 
+    """ 
+    Structured parse results, to provide multiple means of access to the parsed data: 
+       - as a list (C{len(results)}) 
+       - by list index (C{results[0], results[1]}, etc.) 
+       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName}) 
+ 
+    Example:: 
+        integer = Word(nums) 
+        date_str = (integer.setResultsName("year") + '/'  
+                        + integer.setResultsName("month") + '/'  
+                        + integer.setResultsName("day")) 
+        # equivalent form: 
+        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+ 
+        # parseString returns a ParseResults object 
+        result = date_str.parseString("1999/12/31") 
+ 
+        def test(s, fn=repr): 
+            print("%s -> %s" % (s, fn(eval(s)))) 
+        test("list(result)") 
+        test("result[0]") 
+        test("result['month']") 
+        test("result.day") 
+        test("'month' in result") 
+        test("'minutes' in result") 
+        test("result.dump()", str) 
+    prints:: 
+        list(result) -> ['1999', '/', '12', '/', '31'] 
+        result[0] -> '1999' 
+        result['month'] -> '12' 
+        result.day -> '31' 
+        'month' in result -> True 
+        'minutes' in result -> False 
+        result.dump() -> ['1999', '/', '12', '/', '31'] 
+        - day: 31 
+        - month: 12 
+        - year: 1999 
+    """ 
+    def __new__(cls, toklist=None, name=None, asList=True, modal=True ): 
+        if isinstance(toklist, cls): 
+            return toklist 
+        retobj = object.__new__(cls) 
+        retobj.__doinit = True 
+        return retobj 
+ 
+    # Performance tuning: we construct a *lot* of these, so keep this 
+    # constructor as small and fast as possible 
+    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ): 
+        if self.__doinit: 
+            self.__doinit = False 
+            self.__name = None 
+            self.__parent = None 
+            self.__accumNames = {} 
+            self.__asList = asList 
+            self.__modal = modal 
+            if toklist is None: 
+                toklist = [] 
+            if isinstance(toklist, list): 
+                self.__toklist = toklist[:] 
+            elif isinstance(toklist, _generatorType): 
+                self.__toklist = list(toklist) 
+            else: 
+                self.__toklist = [toklist] 
+            self.__tokdict = dict() 
+ 
+        if name is not None and name: 
+            if not modal: 
+                self.__accumNames[name] = 0 
+            if isinstance(name,int): 
+                name = _ustr(name) # will always return a str, but use _ustr for consistency 
+            self.__name = name 
+            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])): 
+                if isinstance(toklist,basestring): 
+                    toklist = [ toklist ] 
+                if asList: 
+                    if isinstance(toklist,ParseResults): 
+                        self[name] = _ParseResultsWithOffset(toklist.copy(),0) 
+                    else: 
+                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0) 
+                    self[name].__name = name 
+                else: 
+                    try: 
+                        self[name] = toklist[0] 
+                    except (KeyError,TypeError,IndexError): 
+                        self[name] = toklist 
+ 
+    def __getitem__( self, i ): 
+        if isinstance( i, (int,slice) ): 
+            return self.__toklist[i] 
+        else: 
+            if i not in self.__accumNames: 
+                return self.__tokdict[i][-1][0] 
+            else: 
+                return ParseResults([ v[0] for v in self.__tokdict[i] ]) 
+ 
+    def __setitem__( self, k, v, isinstance=isinstance ): 
+        if isinstance(v,_ParseResultsWithOffset): 
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v] 
+            sub = v[0] 
+        elif isinstance(k,(int,slice)): 
+            self.__toklist[k] = v 
+            sub = v 
+        else: 
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)] 
+            sub = v 
+        if isinstance(sub,ParseResults): 
+            sub.__parent = wkref(self) 
+ 
+    def __delitem__( self, i ): 
+        if isinstance(i,(int,slice)): 
+            mylen = len( self.__toklist ) 
+            del self.__toklist[i] 
+ 
+            # convert int to slice 
+            if isinstance(i, int): 
+                if i < 0: 
+                    i += mylen 
+                i = slice(i, i+1) 
+            # get removed indices 
+            removed = list(range(*i.indices(mylen))) 
+            removed.reverse() 
+            # fixup indices in token dictionary 
+            for name,occurrences in self.__tokdict.items(): 
+                for j in removed: 
+                    for k, (value, position) in enumerate(occurrences): 
+                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j)) 
+        else: 
+            del self.__tokdict[i] 
+ 
+    def __contains__( self, k ): 
+        return k in self.__tokdict 
+ 
+    def __len__( self ): return len( self.__toklist ) 
+    def __bool__(self): return ( not not self.__toklist ) 
+    __nonzero__ = __bool__ 
+    def __iter__( self ): return iter( self.__toklist ) 
+    def __reversed__( self ): return iter( self.__toklist[::-1] ) 
+    def _iterkeys( self ): 
+        if hasattr(self.__tokdict, "iterkeys"): 
+            return self.__tokdict.iterkeys() 
+        else: 
+            return iter(self.__tokdict) 
+ 
+    def _itervalues( self ): 
+        return (self[k] for k in self._iterkeys()) 
+             
+    def _iteritems( self ): 
+        return ((k, self[k]) for k in self._iterkeys()) 
+ 
+    if PY_3: 
+        keys = _iterkeys        
+        """Returns an iterator of all named result keys (Python 3.x only).""" 
+ 
+        values = _itervalues 
+        """Returns an iterator of all named result values (Python 3.x only).""" 
+ 
+        items = _iteritems 
+        """Returns an iterator of all named result key-value tuples (Python 3.x only).""" 
+ 
+    else: 
+        iterkeys = _iterkeys 
+        """Returns an iterator of all named result keys (Python 2.x only).""" 
+ 
+        itervalues = _itervalues 
+        """Returns an iterator of all named result values (Python 2.x only).""" 
+ 
+        iteritems = _iteritems 
+        """Returns an iterator of all named result key-value tuples (Python 2.x only).""" 
+ 
+        def keys( self ): 
+            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x).""" 
+            return list(self.iterkeys()) 
+ 
+        def values( self ): 
+            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x).""" 
+            return list(self.itervalues()) 
+                 
+        def items( self ): 
+            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x).""" 
+            return list(self.iteritems()) 
+ 
+    def haskeys( self ): 
+        """Since keys() returns an iterator, this method is helpful in bypassing 
+           code that looks for the existence of any defined results names.""" 
+        return bool(self.__tokdict) 
+         
+    def pop( self, *args, **kwargs): 
+        """ 
+        Removes and returns item at specified index (default=C{last}). 
+        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no 
+        argument or an integer argument, it will use C{list} semantics 
+        and pop tokens from the list of parsed tokens. If passed a  
+        non-integer argument (most likely a string), it will use C{dict} 
+        semantics and pop the corresponding value from any defined  
+        results names. A second default return value argument is  
+        supported, just as in C{dict.pop()}. 
+ 
+        Example:: 
+            def remove_first(tokens): 
+                tokens.pop(0) 
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321'] 
+            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321'] 
+ 
+            label = Word(alphas) 
+            patt = label("LABEL") + OneOrMore(Word(nums)) 
+            print(patt.parseString("AAB 123 321").dump()) 
+ 
+            # Use pop() in a parse action to remove named result (note that corresponding value is not 
+            # removed from list form of results) 
+            def remove_LABEL(tokens): 
+                tokens.pop("LABEL") 
+                return tokens 
+            patt.addParseAction(remove_LABEL) 
+            print(patt.parseString("AAB 123 321").dump()) 
+        prints:: 
+            ['AAB', '123', '321'] 
+            - LABEL: AAB 
+ 
+            ['AAB', '123', '321'] 
+        """ 
+        if not args: 
+            args = [-1] 
+        for k,v in kwargs.items(): 
+            if k == 'default': 
+                args = (args[0], v) 
+            else: 
+                raise TypeError("pop() got an unexpected keyword argument '%s'" % k) 
+        if (isinstance(args[0], int) or  
+                        len(args) == 1 or  
+                        args[0] in self): 
+            index = args[0] 
+            ret = self[index] 
+            del self[index] 
+            return ret 
+        else: 
+            defaultvalue = args[1] 
+            return defaultvalue 
+ 
+    def get(self, key, defaultValue=None): 
+        """ 
+        Returns named result matching the given key, or if there is no 
+        such name, then returns the given C{defaultValue} or C{None} if no 
+        C{defaultValue} is specified. 
+ 
+        Similar to C{dict.get()}. 
+         
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")            
+ 
+            result = date_str.parseString("1999/12/31") 
+            print(result.get("year")) # -> '1999' 
+            print(result.get("hour", "not specified")) # -> 'not specified' 
+            print(result.get("hour")) # -> None 
+        """ 
+        if key in self: 
+            return self[key] 
+        else: 
+            return defaultValue 
+ 
+    def insert( self, index, insStr ): 
+        """ 
+        Inserts new element at location index in the list of parsed tokens. 
+         
+        Similar to C{list.insert()}. 
+ 
+        Example:: 
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321'] 
+ 
+            # use a parse action to insert the parse location in the front of the parsed results 
+            def insert_locn(locn, tokens): 
+                tokens.insert(0, locn) 
+            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321'] 
+        """ 
+        self.__toklist.insert(index, insStr) 
+        # fixup indices in token dictionary 
+        for name,occurrences in self.__tokdict.items(): 
+            for k, (value, position) in enumerate(occurrences): 
+                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index)) 
+ 
+    def append( self, item ): 
+        """ 
+        Add single element to end of ParseResults list of elements. 
+ 
+        Example:: 
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321'] 
+             
+            # use a parse action to compute the sum of the parsed integers, and add it to the end 
+            def append_sum(tokens): 
+                tokens.append(sum(map(int, tokens))) 
+            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444] 
+        """ 
+        self.__toklist.append(item) 
+ 
+    def extend( self, itemseq ): 
+        """ 
+        Add sequence of elements to end of ParseResults list of elements. 
+ 
+        Example:: 
+            patt = OneOrMore(Word(alphas)) 
+             
+            # use a parse action to append the reverse of the matched strings, to make a palindrome 
+            def make_palindrome(tokens): 
+                tokens.extend(reversed([t[::-1] for t in tokens])) 
+                return ''.join(tokens) 
+            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl' 
+        """ 
+        if isinstance(itemseq, ParseResults): 
+            self += itemseq 
+        else: 
+            self.__toklist.extend(itemseq) 
+ 
+    def clear( self ): 
+        """ 
+        Clear all elements and results names. 
+        """ 
+        del self.__toklist[:] 
+        self.__tokdict.clear() 
+ 
+    def __getattr__( self, name ): 
+        try: 
+            return self[name] 
+        except KeyError: 
+            return "" 
+             
+        if name in self.__tokdict: 
+            if name not in self.__accumNames: 
+                return self.__tokdict[name][-1][0] 
+            else: 
+                return ParseResults([ v[0] for v in self.__tokdict[name] ]) 
+        else: 
+            return "" 
+ 
+    def __add__( self, other ): 
+        ret = self.copy() 
+        ret += other 
+        return ret 
+ 
+    def __iadd__( self, other ): 
+        if other.__tokdict: 
+            offset = len(self.__toklist) 
+            addoffset = lambda a: offset if a<0 else a+offset 
+            otheritems = other.__tokdict.items() 
+            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) ) 
+                                for (k,vlist) in otheritems for v in vlist] 
+            for k,v in otherdictitems: 
+                self[k] = v 
+                if isinstance(v[0],ParseResults): 
+                    v[0].__parent = wkref(self) 
+             
+        self.__toklist += other.__toklist 
+        self.__accumNames.update( other.__accumNames ) 
+        return self 
+ 
+    def __radd__(self, other): 
+        if isinstance(other,int) and other == 0: 
+            # useful for merging many ParseResults using sum() builtin 
+            return self.copy() 
+        else: 
+            # this may raise a TypeError - so be it 
+            return other + self 
+         
+    def __repr__( self ): 
+        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) ) 
+ 
+    def __str__( self ): 
+        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']' 
+ 
+    def _asStringList( self, sep='' ): 
+        out = [] 
+        for item in self.__toklist: 
+            if out and sep: 
+                out.append(sep) 
+            if isinstance( item, ParseResults ): 
+                out += item._asStringList() 
+            else: 
+                out.append( _ustr(item) ) 
+        return out 
+ 
+    def asList( self ): 
+        """ 
+        Returns the parse results as a nested list of matching tokens, all converted to strings. 
+ 
+        Example:: 
+            patt = OneOrMore(Word(alphas)) 
+            result = patt.parseString("sldkj lsdkj sldkj") 
+            # even though the result prints in string-like form, it is actually a pyparsing ParseResults 
+            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj'] 
+             
+            # Use asList() to create an actual list 
+            result_list = result.asList() 
+            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj'] 
+        """ 
+        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist] 
+ 
+    def asDict( self ): 
+        """ 
+        Returns the named parse results as a nested dictionary. 
+ 
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+             
+            result = date_str.parseString('12/31/1999') 
+            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]}) 
+             
+            result_dict = result.asDict() 
+            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'} 
+ 
+            # even though a ParseResults supports dict-like access, sometime you just need to have a dict 
+            import json 
+            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable 
+            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"} 
+        """ 
+        if PY_3: 
+            item_fn = self.items 
+        else: 
+            item_fn = self.iteritems 
+             
+        def toItem(obj): 
+            if isinstance(obj, ParseResults): 
+                if obj.haskeys(): 
+                    return obj.asDict() 
+                else: 
+                    return [toItem(v) for v in obj] 
+            else: 
+                return obj 
+                 
+        return dict((k,toItem(v)) for k,v in item_fn()) 
+ 
+    def copy( self ): 
+        """ 
+        Returns a new copy of a C{ParseResults} object. 
+        """ 
+        ret = ParseResults( self.__toklist ) 
+        ret.__tokdict = self.__tokdict.copy() 
+        ret.__parent = self.__parent 
+        ret.__accumNames.update( self.__accumNames ) 
+        ret.__name = self.__name 
+        return ret 
+ 
+    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ): 
+        """ 
+        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names. 
+        """ 
+        nl = "\n" 
+        out = [] 
+        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items() 
+                                                            for v in vlist) 
+        nextLevelIndent = indent + "  " 
+ 
+        # collapse out indents if formatting is not desired 
+        if not formatted: 
+            indent = "" 
+            nextLevelIndent = "" 
+            nl = "" 
+ 
+        selfTag = None 
+        if doctag is not None: 
+            selfTag = doctag 
+        else: 
+            if self.__name: 
+                selfTag = self.__name 
+ 
+        if not selfTag: 
+            if namedItemsOnly: 
+                return "" 
+            else: 
+                selfTag = "ITEM" 
+ 
+        out += [ nl, indent, "<", selfTag, ">" ] 
+ 
+        for i,res in enumerate(self.__toklist): 
+            if isinstance(res,ParseResults): 
+                if i in namedItems: 
+                    out += [ res.asXML(namedItems[i], 
+                                        namedItemsOnly and doctag is None, 
+                                        nextLevelIndent, 
+                                        formatted)] 
+                else: 
+                    out += [ res.asXML(None, 
+                                        namedItemsOnly and doctag is None, 
+                                        nextLevelIndent, 
+                                        formatted)] 
+            else: 
+                # individual token, see if there is a name for it 
+                resTag = None 
+                if i in namedItems: 
+                    resTag = namedItems[i] 
+                if not resTag: 
+                    if namedItemsOnly: 
+                        continue 
+                    else: 
+                        resTag = "ITEM" 
+                xmlBodyText = _xml_escape(_ustr(res)) 
+                out += [ nl, nextLevelIndent, "<", resTag, ">", 
+                                                xmlBodyText, 
+                                                "</", resTag, ">" ] 
+ 
+        out += [ nl, indent, "</", selfTag, ">" ] 
+        return "".join(out) 
+ 
+    def __lookup(self,sub): 
+        for k,vlist in self.__tokdict.items(): 
+            for v,loc in vlist: 
+                if sub is v: 
+                    return k 
+        return None 
+ 
+    def getName(self): 
+        r""" 
+        Returns the results name for this token expression. Useful when several  
+        different expressions might match at a particular location. 
+ 
+        Example:: 
+            integer = Word(nums) 
+            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d") 
+            house_number_expr = Suppress('#') + Word(nums, alphanums) 
+            user_data = (Group(house_number_expr)("house_number")  
+                        | Group(ssn_expr)("ssn") 
+                        | Group(integer)("age")) 
+            user_info = OneOrMore(user_data) 
+             
+            result = user_info.parseString("22 111-22-3333 #221B") 
+            for item in result: 
+                print(item.getName(), ':', item[0]) 
+        prints:: 
+            age : 22 
+            ssn : 111-22-3333 
+            house_number : 221B 
+        """ 
+        if self.__name: 
+            return self.__name 
+        elif self.__parent: 
+            par = self.__parent() 
+            if par: 
+                return par.__lookup(self) 
+            else: 
+                return None 
+        elif (len(self) == 1 and 
+               len(self.__tokdict) == 1 and 
+               next(iter(self.__tokdict.values()))[0][1] in (0,-1)): 
+            return next(iter(self.__tokdict.keys())) 
+        else: 
+            return None 
+ 
+    def dump(self, indent='', depth=0, full=True): 
+        """ 
+        Diagnostic method for listing out the contents of a C{ParseResults}. 
+        Accepts an optional C{indent} argument so that this string can be embedded 
+        in a nested display of other data. 
+ 
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+             
+            result = date_str.parseString('12/31/1999') 
+            print(result.dump()) 
+        prints:: 
+            ['12', '/', '31', '/', '1999'] 
+            - day: 1999 
+            - month: 31 
+            - year: 12 
+        """ 
+        out = [] 
+        NL = '\n' 
+        out.append( indent+_ustr(self.asList()) ) 
+        if full: 
+            if self.haskeys(): 
+                items = sorted((str(k), v) for k,v in self.items()) 
+                for k,v in items: 
+                    if out: 
+                        out.append(NL) 
+                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) ) 
+                    if isinstance(v,ParseResults): 
+                        if v: 
+                            out.append( v.dump(indent,depth+1) ) 
+                        else: 
+                            out.append(_ustr(v)) 
+                    else: 
+                        out.append(repr(v)) 
+            elif any(isinstance(vv,ParseResults) for vv in self): 
+                v = self 
+                for i,vv in enumerate(v): 
+                    if isinstance(vv,ParseResults): 
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) )) 
+                    else: 
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv))) 
+             
+        return "".join(out) 
+ 
+    def pprint(self, *args, **kwargs): 
+        """ 
+        Pretty-printer for parsed results as a list, using the C{pprint} module. 
+        Accepts additional positional or keyword args as defined for the  
+        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint}) 
+ 
+        Example:: 
+            ident = Word(alphas, alphanums) 
+            num = Word(nums) 
+            func = Forward() 
+            term = ident | num | Group('(' + func + ')') 
+            func <<= ident + Group(Optional(delimitedList(term))) 
+            result = func.parseString("fna a,b,(fnb c,d,200),100") 
+            result.pprint(width=40) 
+        prints:: 
+            ['fna', 
+             ['a', 
+              'b', 
+              ['(', 'fnb', ['c', 'd', '200'], ')'], 
+              '100']] 
+        """ 
+        pprint.pprint(self.asList(), *args, **kwargs) 
+ 
+    # add support for pickle protocol 
+    def __getstate__(self): 
+        return ( self.__toklist, 
+                 ( self.__tokdict.copy(), 
+                   self.__parent is not None and self.__parent() or None, 
+                   self.__accumNames, 
+                   self.__name ) ) 
+ 
+    def __setstate__(self,state): 
+        self.__toklist = state[0] 
+        (self.__tokdict, 
+         par, 
+         inAccumNames, 
+         self.__name) = state[1] 
+        self.__accumNames = {} 
+        self.__accumNames.update(inAccumNames) 
+        if par is not None: 
+            self.__parent = wkref(par) 
+        else: 
+            self.__parent = None 
+ 
+    def __getnewargs__(self): 
+        return self.__toklist, self.__name, self.__asList, self.__modal 
+ 
+    def __dir__(self): 
+        return (dir(type(self)) + list(self.keys())) 
+ 
+MutableMapping.register(ParseResults) 
+ 
+def col (loc,strg): 
+    """Returns current column within a string, counting newlines as line separators. 
+   The first column is number 1. 
+ 
+   Note: the default parsing behavior is to expand tabs in the input string 
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information 
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a 
+   consistent view of the parsed string, the parse location, and line and column 
+   positions within the parsed string. 
+   """ 
+    s = strg 
+    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc) 
+ 
+def lineno(loc,strg): 
+    """Returns current line number within a string, counting newlines as line separators. 
+   The first line is number 1. 
+ 
+   Note: the default parsing behavior is to expand tabs in the input string 
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information 
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a 
+   consistent view of the parsed string, the parse location, and line and column 
+   positions within the parsed string. 
+   """ 
+    return strg.count("\n",0,loc) + 1 
+ 
+def line( loc, strg ): 
+    """Returns the line of text containing loc within a string, counting newlines as line separators. 
+       """ 
+    lastCR = strg.rfind("\n", 0, loc) 
+    nextCR = strg.find("\n", loc) 
+    if nextCR >= 0: 
+        return strg[lastCR+1:nextCR] 
+    else: 
+        return strg[lastCR+1:] 
+ 
+def _defaultStartDebugAction( instring, loc, expr ): 
+    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))) 
+ 
+def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ): 
+    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList())) 
+ 
+def _defaultExceptionDebugAction( instring, loc, expr, exc ): 
+    print ("Exception raised:" + _ustr(exc)) 
+ 
+def nullDebugAction(*args): 
+    """'Do-nothing' debug action, to suppress debugging output during parsing.""" 
+    pass 
+ 
+# Only works on Python 3.x - nonlocal is toxic to Python 2 installs 
+#~ 'decorator to trim function calls to match the arity of the target' 
+#~ def _trim_arity(func, maxargs=3): 
+    #~ if func in singleArgBuiltins: 
+        #~ return lambda s,l,t: func(t) 
+    #~ limit = 0 
+    #~ foundArity = False 
+    #~ def wrapper(*args): 
+        #~ nonlocal limit,foundArity 
+        #~ while 1: 
+            #~ try: 
+                #~ ret = func(*args[limit:]) 
+                #~ foundArity = True 
+                #~ return ret 
+            #~ except TypeError: 
+                #~ if limit == maxargs or foundArity: 
+                    #~ raise 
+                #~ limit += 1 
+                #~ continue 
+    #~ return wrapper 
+ 
+# this version is Python 2.x-3.x cross-compatible 
+'decorator to trim function calls to match the arity of the target' 
+def _trim_arity(func, maxargs=2): 
+    if func in singleArgBuiltins: 
+        return lambda s,l,t: func(t) 
+    limit = [0] 
+    foundArity = [False] 
+     
+    # traceback return data structure changed in Py3.5 - normalize back to plain tuples 
+    if system_version[:2] >= (3,5): 
+        def extract_stack(limit=0): 
+            # special handling for Python 3.5.0 - extra deep call stack by 1 
+            offset = -3 if system_version == (3,5,0) else -2 
+            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset] 
+            return [frame_summary[:2]] 
+        def extract_tb(tb, limit=0): 
+            frames = traceback.extract_tb(tb, limit=limit) 
+            frame_summary = frames[-1] 
+            return [frame_summary[:2]] 
+    else: 
+        extract_stack = traceback.extract_stack 
+        extract_tb = traceback.extract_tb 
+     
+    # synthesize what would be returned by traceback.extract_stack at the call to  
+    # user's parse action 'func', so that we don't incur call penalty at parse time 
+     
+    LINE_DIFF = 6 
+    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND  
+    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!! 
+    this_line = extract_stack(limit=2)[-1] 
+    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF) 
+ 
+    def wrapper(*args): 
+        while 1: 
+            try: 
+                ret = func(*args[limit[0]:]) 
+                foundArity[0] = True 
+                return ret 
+            except TypeError: 
+                # re-raise TypeErrors if they did not come from our arity testing 
+                if foundArity[0]: 
+                    raise 
+                else: 
+                    try: 
+                        tb = sys.exc_info()[-1] 
+                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth: 
+                            raise 
+                    finally: 
+                        del tb 
+ 
+                if limit[0] <= maxargs: 
+                    limit[0] += 1 
+                    continue 
+                raise 
+ 
+    # copy func name to wrapper for sensible debug output 
+    func_name = "<parse action>" 
+    try: 
+        func_name = getattr(func, '__name__',  
+                            getattr(func, '__class__').__name__) 
+    except Exception: 
+        func_name = str(func) 
+    wrapper.__name__ = func_name 
+ 
+    return wrapper 
+ 
+class ParserElement(object): 
+    """Abstract base level parser element class.""" 
+    DEFAULT_WHITE_CHARS = " \n\t\r" 
+    verbose_stacktrace = False 
+ 
+    @staticmethod 
+    def setDefaultWhitespaceChars( chars ): 
+        r""" 
+        Overrides the default whitespace chars 
+ 
+        Example:: 
+            # default whitespace chars are space, <TAB> and newline 
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl'] 
+             
+            # change to just treat newline as significant 
+            ParserElement.setDefaultWhitespaceChars(" \t") 
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def'] 
+        """ 
+        ParserElement.DEFAULT_WHITE_CHARS = chars 
+ 
+    @staticmethod 
+    def inlineLiteralsUsing(cls): 
+        """ 
+        Set class to be used for inclusion of string literals into a parser. 
+         
+        Example:: 
+            # default literal class used is Literal 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")            
+ 
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31'] 
+ 
+ 
+            # change to Suppress 
+            ParserElement.inlineLiteralsUsing(Suppress) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")            
+ 
+            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31'] 
+        """ 
+        ParserElement._literalStringClass = cls 
+ 
+    def __init__( self, savelist=False ): 
+        self.parseAction = list() 
+        self.failAction = None 
+        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall 
+        self.strRepr = None 
+        self.resultsName = None 
+        self.saveAsList = savelist 
+        self.skipWhitespace = True 
+        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS 
+        self.copyDefaultWhiteChars = True 
+        self.mayReturnEmpty = False # used when checking for left-recursion 
+        self.keepTabs = False 
+        self.ignoreExprs = list() 
+        self.debug = False 
+        self.streamlined = False 
+        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index 
+        self.errmsg = "" 
+        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all) 
+        self.debugActions = ( None, None, None ) #custom debug actions 
+        self.re = None 
+        self.callPreparse = True # used to avoid redundant calls to preParse 
+        self.callDuringTry = False 
+ 
+    def copy( self ): 
+        """ 
+        Make a copy of this C{ParserElement}.  Useful for defining different parse actions 
+        for the same parsing pattern, using copies of the original parse element. 
+         
+        Example:: 
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K") 
+            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M") 
+             
+            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M")) 
+        prints:: 
+            [5120, 100, 655360, 268435456] 
+        Equivalent form of C{expr.copy()} is just C{expr()}:: 
+            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M") 
+        """ 
+        cpy = copy.copy( self ) 
+        cpy.parseAction = self.parseAction[:] 
+        cpy.ignoreExprs = self.ignoreExprs[:] 
+        if self.copyDefaultWhiteChars: 
+            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS 
+        return cpy 
+ 
+    def setName( self, name ): 
+        """ 
+        Define name for this expression, makes debugging and exception messages clearer. 
+         
+        Example:: 
+            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1) 
+            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1) 
+        """ 
+        self.name = name 
+        self.errmsg = "Expected " + self.name 
+        if hasattr(self,"exception"): 
+            self.exception.msg = self.errmsg 
+        return self 
+ 
+    def setResultsName( self, name, listAllMatches=False ): 
+        """ 
+        Define name for referencing matching tokens as a nested attribute 
+        of the returned parse results. 
+        NOTE: this returns a *copy* of the original C{ParserElement} object; 
+        this is so that the client can define a basic element, such as an 
+        integer, and reference it in multiple places with different names. 
+ 
+        You can also set results names using the abbreviated syntax, 
+        C{expr("name")} in place of C{expr.setResultsName("name")} -  
+        see L{I{__call__}<__call__>}. 
+ 
+        Example:: 
+            date_str = (integer.setResultsName("year") + '/'  
+                        + integer.setResultsName("month") + '/'  
+                        + integer.setResultsName("day")) 
+ 
+            # equivalent form: 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+        """ 
+        newself = self.copy() 
+        if name.endswith("*"): 
+            name = name[:-1] 
+            listAllMatches=True 
+        newself.resultsName = name 
+        newself.modalResults = not listAllMatches 
+        return newself 
+ 
+    def setBreak(self,breakFlag = True): 
+        """Method to invoke the Python pdb debugger when this element is 
+           about to be parsed. Set C{breakFlag} to True to enable, False to 
+           disable. 
+        """ 
+        if breakFlag: 
+            _parseMethod = self._parse 
+            def breaker(instring, loc, doActions=True, callPreParse=True): 
+                import pdb 
+                pdb.set_trace() 
+                return _parseMethod( instring, loc, doActions, callPreParse ) 
+            breaker._originalParseMethod = _parseMethod 
+            self._parse = breaker 
+        else: 
+            if hasattr(self._parse,"_originalParseMethod"): 
+                self._parse = self._parse._originalParseMethod 
+        return self 
+ 
+    def setParseAction( self, *fns, **kwargs ): 
+        """ 
+        Define one or more actions to perform when successfully matching parse element definition. 
+        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)}, 
+        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where: 
+         - s   = the original string being parsed (see note below) 
+         - loc = the location of the matching substring 
+         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object 
+        If the functions in fns modify the tokens, they can return them as the return 
+        value from fn, and the modified list of tokens will replace the original. 
+        Otherwise, fn does not need to return any value. 
+ 
+        Optional keyword arguments: 
+         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing 
+ 
+        Note: the default parsing behavior is to expand tabs in the input string 
+        before starting the parsing process.  See L{I{parseString}<parseString>} for more information 
+        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a 
+        consistent view of the parsed string, the parse location, and line and column 
+        positions within the parsed string. 
+         
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer + '/' + integer + '/' + integer 
+ 
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31'] 
+ 
+            # use parse action to convert to ints at parse time 
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+            date_str = integer + '/' + integer + '/' + integer 
+ 
+            # note that integer fields are now ints, not strings 
+            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31] 
+        """ 
+        self.parseAction = list(map(_trim_arity, list(fns))) 
+        self.callDuringTry = kwargs.get("callDuringTry", False) 
+        return self 
+ 
+    def addParseAction( self, *fns, **kwargs ): 
+        """ 
+        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}. 
+         
+        See examples in L{I{copy}<copy>}. 
+        """ 
+        self.parseAction += list(map(_trim_arity, list(fns))) 
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False) 
+        return self 
+ 
+    def addCondition(self, *fns, **kwargs): 
+        """Add a boolean predicate function to expression's list of parse actions. See  
+        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction},  
+        functions passed to C{addCondition} need to return boolean success/fail of the condition. 
+ 
+        Optional keyword arguments: 
+         - message = define a custom message to be used in the raised exception 
+         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException 
+          
+        Example:: 
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+            year_int = integer.copy() 
+            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later") 
+            date_str = year_int + '/' + integer + '/' + integer 
+ 
+            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1) 
+        """ 
+        msg = kwargs.get("message", "failed user-defined condition") 
+        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException 
+        for fn in fns: 
+            def pa(s,l,t): 
+                if not bool(_trim_arity(fn)(s,l,t)): 
+                    raise exc_type(s,l,msg) 
+            self.parseAction.append(pa) 
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False) 
+        return self 
+ 
+    def setFailAction( self, fn ): 
+        """Define action to perform if parsing fails at this expression. 
+           Fail acton fn is a callable function that takes the arguments 
+           C{fn(s,loc,expr,err)} where: 
+            - s = string being parsed 
+            - loc = location where expression match was attempted and failed 
+            - expr = the parse expression that failed 
+            - err = the exception thrown 
+           The function returns no value.  It may throw C{L{ParseFatalException}} 
+           if it is desired to stop parsing immediately.""" 
+        self.failAction = fn 
+        return self 
+ 
+    def _skipIgnorables( self, instring, loc ): 
+        exprsFound = True 
+        while exprsFound: 
+            exprsFound = False 
+            for e in self.ignoreExprs: 
+                try: 
+                    while 1: 
+                        loc,dummy = e._parse( instring, loc ) 
+                        exprsFound = True 
+                except ParseException: 
+                    pass 
+        return loc 
+ 
+    def preParse( self, instring, loc ): 
+        if self.ignoreExprs: 
+            loc = self._skipIgnorables( instring, loc ) 
+ 
+        if self.skipWhitespace: 
+            wt = self.whiteChars 
+            instrlen = len(instring) 
+            while loc < instrlen and instring[loc] in wt: 
+                loc += 1 
+ 
+        return loc 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        return loc, [] 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        return tokenlist 
+ 
+    #~ @profile 
+    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ): 
+        debugging = ( self.debug ) #and doActions ) 
+ 
+        if debugging or self.failAction: 
+            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )) 
+            if (self.debugActions[0] ): 
+                self.debugActions[0]( instring, loc, self ) 
+            if callPreParse and self.callPreparse: 
+                preloc = self.preParse( instring, loc ) 
+            else: 
+                preloc = loc 
+            tokensStart = preloc 
+            try: 
+                try: 
+                    loc,tokens = self.parseImpl( instring, preloc, doActions ) 
+                except IndexError: 
+                    raise ParseException( instring, len(instring), self.errmsg, self ) 
+            except ParseBaseException as err: 
+                #~ print ("Exception raised:", err) 
+                if self.debugActions[2]: 
+                    self.debugActions[2]( instring, tokensStart, self, err ) 
+                if self.failAction: 
+                    self.failAction( instring, tokensStart, self, err ) 
+                raise 
+        else: 
+            if callPreParse and self.callPreparse: 
+                preloc = self.preParse( instring, loc ) 
+            else: 
+                preloc = loc 
+            tokensStart = preloc 
+            if self.mayIndexError or preloc >= len(instring): 
+                try: 
+                    loc,tokens = self.parseImpl( instring, preloc, doActions ) 
+                except IndexError: 
+                    raise ParseException( instring, len(instring), self.errmsg, self ) 
+            else: 
+                loc,tokens = self.parseImpl( instring, preloc, doActions ) 
+ 
+        tokens = self.postParse( instring, loc, tokens ) 
+ 
+        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults ) 
+        if self.parseAction and (doActions or self.callDuringTry): 
+            if debugging: 
+                try: 
+                    for fn in self.parseAction: 
+                        tokens = fn( instring, tokensStart, retTokens ) 
+                        if tokens is not None: 
+                            retTokens = ParseResults( tokens, 
+                                                      self.resultsName, 
+                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)), 
+                                                      modal=self.modalResults ) 
+                except ParseBaseException as err: 
+                    #~ print "Exception raised in user parse action:", err 
+                    if (self.debugActions[2] ): 
+                        self.debugActions[2]( instring, tokensStart, self, err ) 
+                    raise 
+            else: 
+                for fn in self.parseAction: 
+                    tokens = fn( instring, tokensStart, retTokens ) 
+                    if tokens is not None: 
+                        retTokens = ParseResults( tokens, 
+                                                  self.resultsName, 
+                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)), 
+                                                  modal=self.modalResults ) 
+        if debugging: 
+            #~ print ("Matched",self,"->",retTokens.asList()) 
+            if (self.debugActions[1] ): 
+                self.debugActions[1]( instring, tokensStart, loc, self, retTokens ) 
+ 
+        return loc, retTokens 
+ 
+    def tryParse( self, instring, loc ): 
+        try: 
+            return self._parse( instring, loc, doActions=False )[0] 
+        except ParseFatalException: 
+            raise ParseException( instring, loc, self.errmsg, self) 
+     
+    def canParseNext(self, instring, loc): 
+        try: 
+            self.tryParse(instring, loc) 
+        except (ParseException, IndexError): 
+            return False 
+        else: 
+            return True 
+ 
+    class _UnboundedCache(object): 
+        def __init__(self): 
+            cache = {} 
+            self.not_in_cache = not_in_cache = object() 
+ 
+            def get(self, key): 
+                return cache.get(key, not_in_cache) 
+ 
+            def set(self, key, value): 
+                cache[key] = value 
+ 
+            def clear(self): 
+                cache.clear() 
+                 
+            def cache_len(self): 
+                return len(cache) 
+ 
+            self.get = types.MethodType(get, self) 
+            self.set = types.MethodType(set, self) 
+            self.clear = types.MethodType(clear, self) 
+            self.__len__ = types.MethodType(cache_len, self) 
+ 
+    if _OrderedDict is not None: 
+        class _FifoCache(object): 
+            def __init__(self, size): 
+                self.not_in_cache = not_in_cache = object() 
+ 
+                cache = _OrderedDict() 
+ 
+                def get(self, key): 
+                    return cache.get(key, not_in_cache) 
+ 
+                def set(self, key, value): 
+                    cache[key] = value 
+                    while len(cache) > size: 
+                        try: 
+                            cache.popitem(False) 
+                        except KeyError: 
+                            pass 
+ 
+                def clear(self): 
+                    cache.clear() 
+ 
+                def cache_len(self): 
+                    return len(cache) 
+ 
+                self.get = types.MethodType(get, self) 
+                self.set = types.MethodType(set, self) 
+                self.clear = types.MethodType(clear, self) 
+                self.__len__ = types.MethodType(cache_len, self) 
+ 
+    else: 
+        class _FifoCache(object): 
+            def __init__(self, size): 
+                self.not_in_cache = not_in_cache = object() 
+ 
+                cache = {} 
+                key_fifo = collections.deque([], size) 
+ 
+                def get(self, key): 
+                    return cache.get(key, not_in_cache) 
+ 
+                def set(self, key, value): 
+                    cache[key] = value 
+                    while len(key_fifo) > size: 
+                        cache.pop(key_fifo.popleft(), None) 
+                    key_fifo.append(key) 
+ 
+                def clear(self): 
+                    cache.clear() 
+                    key_fifo.clear() 
+ 
+                def cache_len(self): 
+                    return len(cache) 
+ 
+                self.get = types.MethodType(get, self) 
+                self.set = types.MethodType(set, self) 
+                self.clear = types.MethodType(clear, self) 
+                self.__len__ = types.MethodType(cache_len, self) 
+ 
+    # argument cache for optimizing repeated calls when backtracking through recursive expressions 
+    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail 
+    packrat_cache_lock = RLock() 
+    packrat_cache_stats = [0, 0] 
+ 
+    # this method gets repeatedly called during backtracking with the same arguments - 
+    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression 
+    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ): 
+        HIT, MISS = 0, 1 
+        lookup = (self, instring, loc, callPreParse, doActions) 
+        with ParserElement.packrat_cache_lock: 
+            cache = ParserElement.packrat_cache 
+            value = cache.get(lookup) 
+            if value is cache.not_in_cache: 
+                ParserElement.packrat_cache_stats[MISS] += 1 
+                try: 
+                    value = self._parseNoCache(instring, loc, doActions, callPreParse) 
+                except ParseBaseException as pe: 
+                    # cache a copy of the exception, without the traceback 
+                    cache.set(lookup, pe.__class__(*pe.args)) 
+                    raise 
+                else: 
+                    cache.set(lookup, (value[0], value[1].copy())) 
+                    return value 
+            else: 
+                ParserElement.packrat_cache_stats[HIT] += 1 
+                if isinstance(value, Exception): 
+                    raise value 
+                return (value[0], value[1].copy()) 
+ 
+    _parse = _parseNoCache 
+ 
+    @staticmethod 
+    def resetCache(): 
+        ParserElement.packrat_cache.clear() 
+        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats) 
+ 
+    _packratEnabled = False 
+    @staticmethod 
+    def enablePackrat(cache_size_limit=128): 
+        """Enables "packrat" parsing, which adds memoizing to the parsing logic. 
+           Repeated parse attempts at the same string location (which happens 
+           often in many complex grammars) can immediately return a cached value, 
+           instead of re-executing parsing/validating code.  Memoizing is done of 
+           both valid results and parsing exceptions. 
+            
+           Parameters: 
+            - cache_size_limit - (default=C{128}) - if an integer value is provided 
+              will limit the size of the packrat cache; if None is passed, then 
+              the cache size will be unbounded; if 0 is passed, the cache will 
+              be effectively disabled. 
+             
+           This speedup may break existing programs that use parse actions that 
+           have side-effects.  For this reason, packrat parsing is disabled when 
+           you first import pyparsing.  To activate the packrat feature, your 
+           program must call the class method C{ParserElement.enablePackrat()}.  If 
+           your program uses C{psyco} to "compile as you go", you must call 
+           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this, 
+           Python will crash.  For best results, call C{enablePackrat()} immediately 
+           after importing pyparsing. 
+            
+           Example:: 
+               import pyparsing 
+               pyparsing.ParserElement.enablePackrat() 
+        """ 
+        if not ParserElement._packratEnabled: 
+            ParserElement._packratEnabled = True 
+            if cache_size_limit is None: 
+                ParserElement.packrat_cache = ParserElement._UnboundedCache() 
+            else: 
+                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit) 
+            ParserElement._parse = ParserElement._parseCache 
+ 
+    def parseString( self, instring, parseAll=False ): 
+        """ 
+        Execute the parse expression with the given string. 
+        This is the main interface to the client code, once the complete 
+        expression has been built. 
+ 
+        If you want the grammar to require that the entire input string be 
+        successfully parsed, then set C{parseAll} to True (equivalent to ending 
+        the grammar with C{L{StringEnd()}}). 
+ 
+        Note: C{parseString} implicitly calls C{expandtabs()} on the input string, 
+        in order to report proper column numbers in parse actions. 
+        If the input string contains tabs and 
+        the grammar uses parse actions that use the C{loc} argument to index into the 
+        string being parsed, you can ensure you have a consistent view of the input 
+        string by: 
+         - calling C{parseWithTabs} on your grammar before calling C{parseString} 
+           (see L{I{parseWithTabs}<parseWithTabs>}) 
+         - define your parse action using the full C{(s,loc,toks)} signature, and 
+           reference the input string using the parse action's C{s} argument 
+         - explictly expand the tabs in your input string before calling 
+           C{parseString} 
+         
+        Example:: 
+            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa'] 
+            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text 
+        """ 
+        ParserElement.resetCache() 
+        if not self.streamlined: 
+            self.streamline() 
+            #~ self.saveAsList = True 
+        for e in self.ignoreExprs: 
+            e.streamline() 
+        if not self.keepTabs: 
+            instring = instring.expandtabs() 
+        try: 
+            loc, tokens = self._parse( instring, 0 ) 
+            if parseAll: 
+                loc = self.preParse( instring, loc ) 
+                se = Empty() + StringEnd() 
+                se._parse( instring, loc ) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+        else: 
+            return tokens 
+ 
+    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ): 
+        """ 
+        Scan the input string for expression matches.  Each match will return the 
+        matching tokens, start location, and end location.  May be called with optional 
+        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If 
+        C{overlap} is specified, then overlapping matches will be reported. 
+ 
+        Note that the start and end locations are reported relative to the string 
+        being parsed.  See L{I{parseString}<parseString>} for more information on parsing 
+        strings with embedded tabs. 
+ 
+        Example:: 
+            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987" 
+            print(source) 
+            for tokens,start,end in Word(alphas).scanString(source): 
+                print(' '*start + '^'*(end-start)) 
+                print(' '*start + tokens[0]) 
+         
+        prints:: 
+         
+            sldjf123lsdjjkf345sldkjf879lkjsfd987 
+            ^^^^^ 
+            sldjf 
+                    ^^^^^^^ 
+                    lsdjjkf 
+                              ^^^^^^ 
+                              sldkjf 
+                                       ^^^^^^ 
+                                       lkjsfd 
+        """ 
+        if not self.streamlined: 
+            self.streamline() 
+        for e in self.ignoreExprs: 
+            e.streamline() 
+ 
+        if not self.keepTabs: 
+            instring = _ustr(instring).expandtabs() 
+        instrlen = len(instring) 
+        loc = 0 
+        preparseFn = self.preParse 
+        parseFn = self._parse 
+        ParserElement.resetCache() 
+        matches = 0 
+        try: 
+            while loc <= instrlen and matches < maxMatches: 
+                try: 
+                    preloc = preparseFn( instring, loc ) 
+                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False ) 
+                except ParseException: 
+                    loc = preloc+1 
+                else: 
+                    if nextLoc > loc: 
+                        matches += 1 
+                        yield tokens, preloc, nextLoc 
+                        if overlap: 
+                            nextloc = preparseFn( instring, loc ) 
+                            if nextloc > loc: 
+                                loc = nextLoc 
+                            else: 
+                                loc += 1 
+                        else: 
+                            loc = nextLoc 
+                    else: 
+                        loc = preloc+1 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def transformString( self, instring ): 
+        """ 
+        Extension to C{L{scanString}}, to modify matching text with modified tokens that may 
+        be returned from a parse action.  To use C{transformString}, define a grammar and 
+        attach a parse action to it that modifies the returned token list. 
+        Invoking C{transformString()} on a target string will then scan for matches, 
+        and replace the matched text patterns according to the logic in the parse 
+        action.  C{transformString()} returns the resulting transformed string. 
+         
+        Example:: 
+            wd = Word(alphas) 
+            wd.setParseAction(lambda toks: toks[0].title()) 
+             
+            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york.")) 
+        Prints:: 
+            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York. 
+        """ 
+        out = [] 
+        lastE = 0 
+        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to 
+        # keep string locs straight between transformString and scanString 
+        self.keepTabs = True 
+        try: 
+            for t,s,e in self.scanString( instring ): 
+                out.append( instring[lastE:s] ) 
+                if t: 
+                    if isinstance(t,ParseResults): 
+                        out += t.asList() 
+                    elif isinstance(t,list): 
+                        out += t 
+                    else: 
+                        out.append(t) 
+                lastE = e 
+            out.append(instring[lastE:]) 
+            out = [o for o in out if o] 
+            return "".join(map(_ustr,_flatten(out))) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def searchString( self, instring, maxMatches=_MAX_INT ): 
+        """ 
+        Another extension to C{L{scanString}}, simplifying the access to the tokens found 
+        to match the given parse expression.  May be called with optional 
+        C{maxMatches} argument, to clip searching after 'n' matches are found. 
+         
+        Example:: 
+            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters 
+            cap_word = Word(alphas.upper(), alphas.lower()) 
+             
+            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")) 
+ 
+            # the sum() builtin can be used to merge results into a single ParseResults object 
+            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))) 
+        prints:: 
+            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']] 
+            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity'] 
+        """ 
+        try: 
+            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ]) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False): 
+        """ 
+        Generator method to split a string using the given expression as a separator. 
+        May be called with optional C{maxsplit} argument, to limit the number of splits; 
+        and the optional C{includeSeparators} argument (default=C{False}), if the separating 
+        matching text should be included in the split results. 
+         
+        Example::         
+            punc = oneOf(list(".,;:/-!?")) 
+            print(list(punc.split("This, this?, this sentence, is badly punctuated!"))) 
+        prints:: 
+            ['This', ' this', '', ' this sentence', ' is badly punctuated', ''] 
+        """ 
+        splits = 0 
+        last = 0 
+        for t,s,e in self.scanString(instring, maxMatches=maxsplit): 
+            yield instring[last:s] 
+            if includeSeparators: 
+                yield t[0] 
+            last = e 
+        yield instring[last:] 
+ 
+    def __add__(self, other ): 
+        """ 
+        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement 
+        converts them to L{Literal}s by default. 
+         
+        Example:: 
+            greet = Word(alphas) + "," + Word(alphas) + "!" 
+            hello = "Hello, World!" 
+            print (hello, "->", greet.parseString(hello)) 
+        Prints:: 
+            Hello, World! -> ['Hello', ',', 'World', '!'] 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return And( [ self, other ] ) 
+ 
+    def __radd__(self, other ): 
+        """ 
+        Implementation of + operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other + self 
+ 
+    def __sub__(self, other): 
+        """ 
+        Implementation of - operator, returns C{L{And}} with error stop 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return self + And._ErrorStop() + other 
+ 
+    def __rsub__(self, other ): 
+        """ 
+        Implementation of - operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other - self 
+ 
+    def __mul__(self,other): 
+        """ 
+        Implementation of * operator, allows use of C{expr * 3} in place of 
+        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer 
+        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples 
+        may also include C{None} as in: 
+         - C{expr*(n,None)} or C{expr*(n,)} is equivalent 
+              to C{expr*n + L{ZeroOrMore}(expr)} 
+              (read as "at least n instances of C{expr}") 
+         - C{expr*(None,n)} is equivalent to C{expr*(0,n)} 
+              (read as "0 to n instances of C{expr}") 
+         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)} 
+         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)} 
+ 
+        Note that C{expr*(None,n)} does not raise an exception if 
+        more than n exprs exist in the input stream; that is, 
+        C{expr*(None,n)} does not enforce a maximum number of expr 
+        occurrences.  If this behavior is desired, then write 
+        C{expr*(None,n) + ~expr} 
+        """ 
+        if isinstance(other,int): 
+            minElements, optElements = other,0 
+        elif isinstance(other,tuple): 
+            other = (other + (None, None))[:2] 
+            if other[0] is None: 
+                other = (0, other[1]) 
+            if isinstance(other[0],int) and other[1] is None: 
+                if other[0] == 0: 
+                    return ZeroOrMore(self) 
+                if other[0] == 1: 
+                    return OneOrMore(self) 
+                else: 
+                    return self*other[0] + ZeroOrMore(self) 
+            elif isinstance(other[0],int) and isinstance(other[1],int): 
+                minElements, optElements = other 
+                optElements -= minElements 
+            else: 
+                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1])) 
+        else: 
+            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other)) 
+ 
+        if minElements < 0: 
+            raise ValueError("cannot multiply ParserElement by negative value") 
+        if optElements < 0: 
+            raise ValueError("second tuple value must be greater or equal to first tuple value") 
+        if minElements == optElements == 0: 
+            raise ValueError("cannot multiply ParserElement by 0 or (0,0)") 
+ 
+        if (optElements): 
+            def makeOptionalList(n): 
+                if n>1: 
+                    return Optional(self + makeOptionalList(n-1)) 
+                else: 
+                    return Optional(self) 
+            if minElements: 
+                if minElements == 1: 
+                    ret = self + makeOptionalList(optElements) 
+                else: 
+                    ret = And([self]*minElements) + makeOptionalList(optElements) 
+            else: 
+                ret = makeOptionalList(optElements) 
+        else: 
+            if minElements == 1: 
+                ret = self 
+            else: 
+                ret = And([self]*minElements) 
+        return ret 
+ 
+    def __rmul__(self, other): 
+        return self.__mul__(other) 
+ 
+    def __or__(self, other ): 
+        """ 
+        Implementation of | operator - returns C{L{MatchFirst}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return MatchFirst( [ self, other ] ) 
+ 
+    def __ror__(self, other ): 
+        """ 
+        Implementation of | operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other | self 
+ 
+    def __xor__(self, other ): 
+        """ 
+        Implementation of ^ operator - returns C{L{Or}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return Or( [ self, other ] ) 
+ 
+    def __rxor__(self, other ): 
+        """ 
+        Implementation of ^ operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other ^ self 
+ 
+    def __and__(self, other ): 
+        """ 
+        Implementation of & operator - returns C{L{Each}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return Each( [ self, other ] ) 
+ 
+    def __rand__(self, other ): 
+        """ 
+        Implementation of & operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other & self 
+ 
+    def __invert__( self ): 
+        """ 
+        Implementation of ~ operator - returns C{L{NotAny}} 
+        """ 
+        return NotAny( self ) 
+ 
+    def __call__(self, name=None): 
+        """ 
+        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}. 
+         
+        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be 
+        passed as C{True}. 
+            
+        If C{name} is omitted, same as calling C{L{copy}}. 
+ 
+        Example:: 
+            # these are equivalent 
+            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno") 
+            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")              
+        """ 
+        if name is not None: 
+            return self.setResultsName(name) 
+        else: 
+            return self.copy() 
+ 
+    def suppress( self ): 
+        """ 
+        Suppresses the output of this C{ParserElement}; useful to keep punctuation from 
+        cluttering up returned output. 
+        """ 
+        return Suppress( self ) 
+ 
+    def leaveWhitespace( self ): 
+        """ 
+        Disables the skipping of whitespace before matching the characters in the 
+        C{ParserElement}'s defined pattern.  This is normally only used internally by 
+        the pyparsing module, but may be needed in some whitespace-sensitive grammars. 
+        """ 
+        self.skipWhitespace = False 
+        return self 
+ 
+    def setWhitespaceChars( self, chars ): 
+        """ 
+        Overrides the default whitespace chars 
+        """ 
+        self.skipWhitespace = True 
+        self.whiteChars = chars 
+        self.copyDefaultWhiteChars = False 
+        return self 
+ 
+    def parseWithTabs( self ): 
+        """ 
+        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string. 
+        Must be called before C{parseString} when the input grammar contains elements that 
+        match C{<TAB>} characters. 
+        """ 
+        self.keepTabs = True 
+        return self 
+ 
+    def ignore( self, other ): 
+        """ 
+        Define expression to be ignored (e.g., comments) while doing pattern 
+        matching; may be called repeatedly, to define multiple comment or other 
+        ignorable patterns. 
+         
+        Example:: 
+            patt = OneOrMore(Word(alphas)) 
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj'] 
+             
+            patt.ignore(cStyleComment) 
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd'] 
+        """ 
+        if isinstance(other, basestring): 
+            other = Suppress(other) 
+ 
+        if isinstance( other, Suppress ): 
+            if other not in self.ignoreExprs: 
+                self.ignoreExprs.append(other) 
+        else: 
+            self.ignoreExprs.append( Suppress( other.copy() ) ) 
+        return self 
+ 
+    def setDebugActions( self, startAction, successAction, exceptionAction ): 
+        """ 
+        Enable display of debugging messages while doing pattern matching. 
+        """ 
+        self.debugActions = (startAction or _defaultStartDebugAction, 
+                             successAction or _defaultSuccessDebugAction, 
+                             exceptionAction or _defaultExceptionDebugAction) 
+        self.debug = True 
+        return self 
+ 
+    def setDebug( self, flag=True ): 
+        """ 
+        Enable display of debugging messages while doing pattern matching. 
+        Set C{flag} to True to enable, False to disable. 
+ 
+        Example:: 
+            wd = Word(alphas).setName("alphaword") 
+            integer = Word(nums).setName("numword") 
+            term = wd | integer 
+             
+            # turn on debugging for wd 
+            wd.setDebug() 
+ 
+            OneOrMore(term).parseString("abc 123 xyz 890") 
+         
+        prints:: 
+            Match alphaword at loc 0(1,1) 
+            Matched alphaword -> ['abc'] 
+            Match alphaword at loc 3(1,4) 
+            Exception raised:Expected alphaword (at char 4), (line:1, col:5) 
+            Match alphaword at loc 7(1,8) 
+            Matched alphaword -> ['xyz'] 
+            Match alphaword at loc 11(1,12) 
+            Exception raised:Expected alphaword (at char 12), (line:1, col:13) 
+            Match alphaword at loc 15(1,16) 
+            Exception raised:Expected alphaword (at char 15), (line:1, col:16) 
+ 
+        The output shown is that produced by the default debug actions - custom debug actions can be 
+        specified using L{setDebugActions}. Prior to attempting 
+        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"} 
+        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"} 
+        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression, 
+        which makes debugging and exception messages easier to understand - for instance, the default 
+        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}. 
+        """ 
+        if flag: 
+            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction ) 
+        else: 
+            self.debug = False 
+        return self 
+ 
+    def __str__( self ): 
+        return self.name 
+ 
+    def __repr__( self ): 
+        return _ustr(self) 
+ 
+    def streamline( self ): 
+        self.streamlined = True 
+        self.strRepr = None 
+        return self 
+ 
+    def checkRecursion( self, parseElementList ): 
+        pass 
+ 
+    def validate( self, validateTrace=[] ): 
+        """ 
+        Check defined expressions for valid structure, check for infinite recursive definitions. 
+        """ 
+        self.checkRecursion( [] ) 
+ 
+    def parseFile( self, file_or_filename, parseAll=False ): 
+        """ 
+        Execute the parse expression on the given file or filename. 
+        If a filename is specified (instead of a file object), 
+        the entire file is opened, read, and closed before parsing. 
+        """ 
+        try: 
+            file_contents = file_or_filename.read() 
+        except AttributeError: 
+            with open(file_or_filename, "r") as f: 
+                file_contents = f.read() 
+        try: 
+            return self.parseString(file_contents, parseAll) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def __eq__(self,other): 
+        if isinstance(other, ParserElement): 
+            return self is other or vars(self) == vars(other) 
+        elif isinstance(other, basestring): 
+            return self.matches(other) 
+        else: 
+            return super(ParserElement,self)==other 
+ 
+    def __ne__(self,other): 
+        return not (self == other) 
+ 
+    def __hash__(self): 
+        return hash(id(self)) 
+ 
+    def __req__(self,other): 
+        return self == other 
+ 
+    def __rne__(self,other): 
+        return not (self == other) 
+ 
+    def matches(self, testString, parseAll=True): 
+        """ 
+        Method for quick testing of a parser against a test string. Good for simple  
+        inline microtests of sub expressions while building up larger parser. 
+            
+        Parameters: 
+         - testString - to test against this expression for a match 
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests 
+             
+        Example:: 
+            expr = Word(nums) 
+            assert expr.matches("100") 
+        """ 
+        try: 
+            self.parseString(_ustr(testString), parseAll=parseAll) 
+            return True 
+        except ParseBaseException: 
+            return False 
+                 
+    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False): 
+        """ 
+        Execute the parse expression on a series of test strings, showing each 
+        test, the parsed results or where the parse failed. Quick and easy way to 
+        run a parse expression against a list of sample strings. 
+            
+        Parameters: 
+         - tests - a list of separate test strings, or a multiline string of test strings 
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests            
+         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test  
+              string; pass None to disable comment filtering 
+         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline; 
+              if False, only dump nested list 
+         - printResults - (default=C{True}) prints test output to stdout 
+         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing 
+ 
+        Returns: a (success, results) tuple, where success indicates that all tests succeeded 
+        (or failed if C{failureTests} is True), and the results contain a list of lines of each  
+        test's output 
+         
+        Example:: 
+            number_expr = pyparsing_common.number.copy() 
+ 
+            result = number_expr.runTests(''' 
+                # unsigned integer 
+                100 
+                # negative integer 
+                -100 
+                # float with scientific notation 
+                6.02e23 
+                # integer with scientific notation 
+                1e-12 
+                ''') 
+            print("Success" if result[0] else "Failed!") 
+ 
+            result = number_expr.runTests(''' 
+                # stray character 
+                100Z 
+                # missing leading digit before '.' 
+                -.100 
+                # too many '.' 
+                3.14.159 
+                ''', failureTests=True) 
+            print("Success" if result[0] else "Failed!") 
+        prints:: 
+            # unsigned integer 
+            100 
+            [100] 
+ 
+            # negative integer 
+            -100 
+            [-100] 
+ 
+            # float with scientific notation 
+            6.02e23 
+            [6.02e+23] 
+ 
+            # integer with scientific notation 
+            1e-12 
+            [1e-12] 
+ 
+            Success 
+             
+            # stray character 
+            100Z 
+               ^ 
+            FAIL: Expected end of text (at char 3), (line:1, col:4) 
+ 
+            # missing leading digit before '.' 
+            -.100 
+            ^ 
+            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1) 
+ 
+            # too many '.' 
+            3.14.159 
+                ^ 
+            FAIL: Expected end of text (at char 4), (line:1, col:5) 
+ 
+            Success 
+ 
+        Each test string must be on a single line. If you want to test a string that spans multiple 
+        lines, create a test like this:: 
+ 
+            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines") 
+         
+        (Note that this is a raw string literal, you must include the leading 'r'.) 
+        """ 
+        if isinstance(tests, basestring): 
+            tests = list(map(str.strip, tests.rstrip().splitlines())) 
+        if isinstance(comment, basestring): 
+            comment = Literal(comment) 
+        allResults = [] 
+        comments = [] 
+        success = True 
+        for t in tests: 
+            if comment is not None and comment.matches(t, False) or comments and not t: 
+                comments.append(t) 
+                continue 
+            if not t: 
+                continue 
+            out = ['\n'.join(comments), t] 
+            comments = [] 
+            try: 
+                t = t.replace(r'\n','\n') 
+                result = self.parseString(t, parseAll=parseAll) 
+                out.append(result.dump(full=fullDump)) 
+                success = success and not failureTests 
+            except ParseBaseException as pe: 
+                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else "" 
+                if '\n' in t: 
+                    out.append(line(pe.loc, t)) 
+                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal) 
+                else: 
+                    out.append(' '*pe.loc + '^' + fatal) 
+                out.append("FAIL: " + str(pe)) 
+                success = success and failureTests 
+                result = pe 
+            except Exception as exc: 
+                out.append("FAIL-EXCEPTION: " + str(exc)) 
+                success = success and failureTests 
+                result = exc 
+ 
+            if printResults: 
+                if fullDump: 
+                    out.append('') 
+                print('\n'.join(out)) 
+ 
+            allResults.append((t, result)) 
+         
+        return success, allResults 
+ 
+         
+class Token(ParserElement): 
+    """ 
+    Abstract C{ParserElement} subclass, for defining atomic matching patterns. 
+    """ 
+    def __init__( self ): 
+        super(Token,self).__init__( savelist=False ) 
+ 
+ 
+class Empty(Token): 
+    """ 
+    An empty token, will always match. 
+    """ 
+    def __init__( self ): 
+        super(Empty,self).__init__() 
+        self.name = "Empty" 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+ 
+ 
+class NoMatch(Token): 
+    """ 
+    A token that will never match. 
+    """ 
+    def __init__( self ): 
+        super(NoMatch,self).__init__() 
+        self.name = "NoMatch" 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+        self.errmsg = "Unmatchable token" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+ 
+class Literal(Token): 
+    """ 
+    Token to exactly match a specified string. 
+     
+    Example:: 
+        Literal('blah').parseString('blah')  # -> ['blah'] 
+        Literal('blah').parseString('blahfooblah')  # -> ['blah'] 
+        Literal('blah').parseString('bla')  # -> Exception: Expected "blah" 
+     
+    For case-insensitive matching, use L{CaselessLiteral}. 
+     
+    For keyword matching (force word break before and after the matched string), 
+    use L{Keyword} or L{CaselessKeyword}. 
+    """ 
+    def __init__( self, matchString ): 
+        super(Literal,self).__init__() 
+        self.match = matchString 
+        self.matchLen = len(matchString) 
+        try: 
+            self.firstMatchChar = matchString[0] 
+        except IndexError: 
+            warnings.warn("null string passed to Literal; use Empty() instead", 
+                            SyntaxWarning, stacklevel=2) 
+            self.__class__ = Empty 
+        self.name = '"%s"' % _ustr(self.match) 
+        self.errmsg = "Expected " + self.name 
+        self.mayReturnEmpty = False 
+        self.mayIndexError = False 
+ 
+    # Performance tuning: this routine gets called a *lot* 
+    # if this is a single character match string  and the first character matches, 
+    # short-circuit as quickly as possible, and avoid calling startswith 
+    #~ @profile 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if (instring[loc] == self.firstMatchChar and 
+            (self.matchLen==1 or instring.startswith(self.match,loc)) ): 
+            return loc+self.matchLen, self.match 
+        raise ParseException(instring, loc, self.errmsg, self) 
+_L = Literal 
+ParserElement._literalStringClass = Literal 
+ 
+class Keyword(Token): 
+    """ 
+    Token to exactly match a specified string as a keyword, that is, it must be 
+    immediately followed by a non-keyword character.  Compare with C{L{Literal}}: 
+     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}. 
+     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'} 
+    Accepts two optional constructor arguments in addition to the keyword string: 
+     - C{identChars} is a string of characters that would be valid identifier characters, 
+          defaulting to all alphanumerics + "_" and "$" 
+     - C{caseless} allows case-insensitive matching, default is C{False}. 
+        
+    Example:: 
+        Keyword("start").parseString("start")  # -> ['start'] 
+        Keyword("start").parseString("starting")  # -> Exception 
+ 
+    For case-insensitive matching, use L{CaselessKeyword}. 
+    """ 
+    DEFAULT_KEYWORD_CHARS = alphanums+"_$" 
+ 
+    def __init__( self, matchString, identChars=None, caseless=False ): 
+        super(Keyword,self).__init__() 
+        if identChars is None: 
+            identChars = Keyword.DEFAULT_KEYWORD_CHARS 
+        self.match = matchString 
+        self.matchLen = len(matchString) 
+        try: 
+            self.firstMatchChar = matchString[0] 
+        except IndexError: 
+            warnings.warn("null string passed to Keyword; use Empty() instead", 
+                            SyntaxWarning, stacklevel=2) 
+        self.name = '"%s"' % self.match 
+        self.errmsg = "Expected " + self.name 
+        self.mayReturnEmpty = False 
+        self.mayIndexError = False 
+        self.caseless = caseless 
+        if caseless: 
+            self.caselessmatch = matchString.upper() 
+            identChars = identChars.upper() 
+        self.identChars = set(identChars) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.caseless: 
+            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and 
+                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and 
+                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ): 
+                return loc+self.matchLen, self.match 
+        else: 
+            if (instring[loc] == self.firstMatchChar and 
+                (self.matchLen==1 or instring.startswith(self.match,loc)) and 
+                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and 
+                (loc == 0 or instring[loc-1] not in self.identChars) ): 
+                return loc+self.matchLen, self.match 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+    def copy(self): 
+        c = super(Keyword,self).copy() 
+        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS 
+        return c 
+ 
+    @staticmethod 
+    def setDefaultKeywordChars( chars ): 
+        """Overrides the default Keyword chars 
+        """ 
+        Keyword.DEFAULT_KEYWORD_CHARS = chars 
+ 
+class CaselessLiteral(Literal): 
+    """ 
+    Token to match a specified string, ignoring case of letters. 
+    Note: the matched results will always be in the case of the given 
+    match string, NOT the case of the input text. 
+ 
+    Example:: 
+        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD'] 
+         
+    (Contrast with example for L{CaselessKeyword}.) 
+    """ 
+    def __init__( self, matchString ): 
+        super(CaselessLiteral,self).__init__( matchString.upper() ) 
+        # Preserve the defining literal. 
+        self.returnString = matchString 
+        self.name = "'%s'" % self.returnString 
+        self.errmsg = "Expected " + self.name 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if instring[ loc:loc+self.matchLen ].upper() == self.match: 
+            return loc+self.matchLen, self.returnString 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class CaselessKeyword(Keyword): 
+    """ 
+    Caseless version of L{Keyword}. 
+ 
+    Example:: 
+        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD'] 
+         
+    (Contrast with example for L{CaselessLiteral}.) 
+    """ 
+    def __init__( self, matchString, identChars=None ): 
+        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True ) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and 
+             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ): 
+            return loc+self.matchLen, self.match 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class CloseMatch(Token): 
+    """ 
+    A variation on L{Literal} which matches "close" matches, that is,  
+    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters: 
+     - C{match_string} - string to be matched 
+     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match 
+     
+    The results from a successful parse will contain the matched text from the input string and the following named results: 
+     - C{mismatches} - a list of the positions within the match_string where mismatches were found 
+     - C{original} - the original match_string used to compare against the input string 
+     
+    If C{mismatches} is an empty list, then the match was an exact match. 
+     
+    Example:: 
+        patt = CloseMatch("ATCATCGAATGGA") 
+        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']}) 
+        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1) 
+ 
+        # exact match 
+        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']}) 
+ 
+        # close match allowing up to 2 mismatches 
+        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2) 
+        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']}) 
+    """ 
+    def __init__(self, match_string, maxMismatches=1): 
+        super(CloseMatch,self).__init__() 
+        self.name = match_string 
+        self.match_string = match_string 
+        self.maxMismatches = maxMismatches 
+        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches) 
+        self.mayIndexError = False 
+        self.mayReturnEmpty = False 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        start = loc 
+        instrlen = len(instring) 
+        maxloc = start + len(self.match_string) 
+ 
+        if maxloc <= instrlen: 
+            match_string = self.match_string 
+            match_stringloc = 0 
+            mismatches = [] 
+            maxMismatches = self.maxMismatches 
+ 
+            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)): 
+                src,mat = s_m 
+                if src != mat: 
+                    mismatches.append(match_stringloc) 
+                    if len(mismatches) > maxMismatches: 
+                        break 
+            else: 
+                loc = match_stringloc + 1 
+                results = ParseResults([instring[start:loc]]) 
+                results['original'] = self.match_string 
+                results['mismatches'] = mismatches 
+                return loc, results 
+ 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+ 
+class Word(Token): 
+    """ 
+    Token for matching words composed of allowed character sets. 
+    Defined with string containing all allowed initial characters, 
+    an optional string containing allowed body characters (if omitted, 
+    defaults to the initial character set), and an optional minimum, 
+    maximum, and/or exact length.  The default value for C{min} is 1 (a 
+    minimum value < 1 is not valid); the default values for C{max} and C{exact} 
+    are 0, meaning no maximum or exact length restriction. An optional 
+    C{excludeChars} parameter can list characters that might be found in  
+    the input C{bodyChars} string; useful to define a word of all printables 
+    except for one or two characters, for instance. 
+     
+    L{srange} is useful for defining custom character set strings for defining  
+    C{Word} expressions, using range notation from regular expression character sets. 
+     
+    A common mistake is to use C{Word} to match a specific literal string, as in  
+    C{Word("Address")}. Remember that C{Word} uses the string argument to define 
+    I{sets} of matchable characters. This expression would match "Add", "AAA", 
+    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'. 
+    To match an exact literal string, use L{Literal} or L{Keyword}. 
+ 
+    pyparsing includes helper strings for building Words: 
+     - L{alphas} 
+     - L{nums} 
+     - L{alphanums} 
+     - L{hexnums} 
+     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.) 
+     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.) 
+     - L{printables} (any non-whitespace character) 
+ 
+    Example:: 
+        # a word composed of digits 
+        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9")) 
+         
+        # a word with a leading capital, and zero or more lowercase 
+        capital_word = Word(alphas.upper(), alphas.lower()) 
+ 
+        # hostnames are alphanumeric, with leading alpha, and '-' 
+        hostname = Word(alphas, alphanums+'-') 
+         
+        # roman numeral (not a strict parser, accepts invalid mix of characters) 
+        roman = Word("IVXLCDM") 
+         
+        # any string of non-whitespace characters, except for ',' 
+        csv_value = Word(printables, excludeChars=",") 
+    """ 
+    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ): 
+        super(Word,self).__init__() 
+        if excludeChars: 
+            initChars = ''.join(c for c in initChars if c not in excludeChars) 
+            if bodyChars: 
+                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars) 
+        self.initCharsOrig = initChars 
+        self.initChars = set(initChars) 
+        if bodyChars : 
+            self.bodyCharsOrig = bodyChars 
+            self.bodyChars = set(bodyChars) 
+        else: 
+            self.bodyCharsOrig = initChars 
+            self.bodyChars = set(initChars) 
+ 
+        self.maxSpecified = max > 0 
+ 
+        if min < 1: 
+            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted") 
+ 
+        self.minLen = min 
+ 
+        if max > 0: 
+            self.maxLen = max 
+        else: 
+            self.maxLen = _MAX_INT 
+ 
+        if exact > 0: 
+            self.maxLen = exact 
+            self.minLen = exact 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayIndexError = False 
+        self.asKeyword = asKeyword 
+ 
+        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0): 
+            if self.bodyCharsOrig == self.initCharsOrig: 
+                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig) 
+            elif len(self.initCharsOrig) == 1: 
+                self.reString = "%s[%s]*" % \ 
+                                      (re.escape(self.initCharsOrig), 
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),) 
+            else: 
+                self.reString = "[%s][%s]*" % \ 
+                                      (_escapeRegexRangeChars(self.initCharsOrig), 
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),) 
+            if self.asKeyword: 
+                self.reString = r"\b"+self.reString+r"\b" 
+            try: 
+                self.re = re.compile( self.reString ) 
+            except Exception: 
+                self.re = None 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.re: 
+            result = self.re.match(instring,loc) 
+            if not result: 
+                raise ParseException(instring, loc, self.errmsg, self) 
+ 
+            loc = result.end() 
+            return loc, result.group() 
+ 
+        if not(instring[ loc ] in self.initChars): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        start = loc 
+        loc += 1 
+        instrlen = len(instring) 
+        bodychars = self.bodyChars 
+        maxloc = start + self.maxLen 
+        maxloc = min( maxloc, instrlen ) 
+        while loc < maxloc and instring[loc] in bodychars: 
+            loc += 1 
+ 
+        throwException = False 
+        if loc - start < self.minLen: 
+            throwException = True 
+        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars: 
+            throwException = True 
+        if self.asKeyword: 
+            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars): 
+                throwException = True 
+ 
+        if throwException: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        return loc, instring[start:loc] 
+ 
+    def __str__( self ): 
+        try: 
+            return super(Word,self).__str__() 
+        except Exception: 
+            pass 
+ 
+ 
+        if self.strRepr is None: 
+ 
+            def charsAsStr(s): 
+                if len(s)>4: 
+                    return s[:4]+"..." 
+                else: 
+                    return s 
+ 
+            if ( self.initCharsOrig != self.bodyCharsOrig ): 
+                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) ) 
+            else: 
+                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig) 
+ 
+        return self.strRepr 
+ 
+ 
+class Regex(Token): 
+    r""" 
+    Token for matching strings that match a given regular expression. 
+    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module. 
+    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as  
+    named parse results. 
+ 
+    Example:: 
+        realnum = Regex(r"[+-]?\d+\.\d*") 
+        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)') 
+        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression 
+        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})") 
+    """ 
+    compiledREtype = type(re.compile("[A-Z]")) 
+    def __init__( self, pattern, flags=0): 
+        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags.""" 
+        super(Regex,self).__init__() 
+ 
+        if isinstance(pattern, basestring): 
+            if not pattern: 
+                warnings.warn("null string passed to Regex; use Empty() instead", 
+                        SyntaxWarning, stacklevel=2) 
+ 
+            self.pattern = pattern 
+            self.flags = flags 
+ 
+            try: 
+                self.re = re.compile(self.pattern, self.flags) 
+                self.reString = self.pattern 
+            except sre_constants.error: 
+                warnings.warn("invalid pattern (%s) passed to Regex" % pattern, 
+                    SyntaxWarning, stacklevel=2) 
+                raise 
+ 
+        elif isinstance(pattern, Regex.compiledREtype): 
+            self.re = pattern 
+            self.pattern = \ 
+            self.reString = str(pattern) 
+            self.flags = flags 
+             
+        else: 
+            raise ValueError("Regex may only be constructed with a string or a compiled RE object") 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayIndexError = False 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        result = self.re.match(instring,loc) 
+        if not result: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        loc = result.end() 
+        d = result.groupdict() 
+        ret = ParseResults(result.group()) 
+        if d: 
+            for k in d: 
+                ret[k] = d[k] 
+        return loc,ret 
+ 
+    def __str__( self ): 
+        try: 
+            return super(Regex,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "Re:(%s)" % repr(self.pattern) 
+ 
+        return self.strRepr 
+ 
+ 
+class QuotedString(Token): 
+    r""" 
+    Token for matching strings that are delimited by quoting characters. 
+     
+    Defined with the following parameters: 
+        - quoteChar - string of one or more characters defining the quote delimiting string 
+        - escChar - character to escape quotes, typically backslash (default=C{None}) 
+        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None}) 
+        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False}) 
+        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True}) 
+        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar) 
+        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True}) 
+ 
+    Example:: 
+        qs = QuotedString('"') 
+        print(qs.searchString('lsjdf "This is the quote" sldjf')) 
+        complex_qs = QuotedString('{{', endQuoteChar='}}') 
+        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf')) 
+        sql_qs = QuotedString('"', escQuote='""') 
+        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf')) 
+    prints:: 
+        [['This is the quote']] 
+        [['This is the "quote"']] 
+        [['This is the quote with "embedded" quotes']] 
+    """ 
+    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True): 
+        super(QuotedString,self).__init__() 
+ 
+        # remove white space from quote chars - wont work anyway 
+        quoteChar = quoteChar.strip() 
+        if not quoteChar: 
+            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2) 
+            raise SyntaxError() 
+ 
+        if endQuoteChar is None: 
+            endQuoteChar = quoteChar 
+        else: 
+            endQuoteChar = endQuoteChar.strip() 
+            if not endQuoteChar: 
+                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2) 
+                raise SyntaxError() 
+ 
+        self.quoteChar = quoteChar 
+        self.quoteCharLen = len(quoteChar) 
+        self.firstQuoteChar = quoteChar[0] 
+        self.endQuoteChar = endQuoteChar 
+        self.endQuoteCharLen = len(endQuoteChar) 
+        self.escChar = escChar 
+        self.escQuote = escQuote 
+        self.unquoteResults = unquoteResults 
+        self.convertWhitespaceEscapes = convertWhitespaceEscapes 
+ 
+        if multiline: 
+            self.flags = re.MULTILINE | re.DOTALL 
+            self.pattern = r'%s(?:[^%s%s]' % \ 
+                ( re.escape(self.quoteChar), 
+                  _escapeRegexRangeChars(self.endQuoteChar[0]), 
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') ) 
+        else: 
+            self.flags = 0 
+            self.pattern = r'%s(?:[^%s\n\r%s]' % \ 
+                ( re.escape(self.quoteChar), 
+                  _escapeRegexRangeChars(self.endQuoteChar[0]), 
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') ) 
+        if len(self.endQuoteChar) > 1: 
+            self.pattern += ( 
+                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]), 
+                                               _escapeRegexRangeChars(self.endQuoteChar[i])) 
+                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')' 
+                ) 
+        if escQuote: 
+            self.pattern += (r'|(?:%s)' % re.escape(escQuote)) 
+        if escChar: 
+            self.pattern += (r'|(?:%s.)' % re.escape(escChar)) 
+            self.escCharReplacePattern = re.escape(self.escChar)+"(.)" 
+        self.pattern += (r')*%s' % re.escape(self.endQuoteChar)) 
+ 
+        try: 
+            self.re = re.compile(self.pattern, self.flags) 
+            self.reString = self.pattern 
+        except sre_constants.error: 
+            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern, 
+                SyntaxWarning, stacklevel=2) 
+            raise 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayIndexError = False 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None 
+        if not result: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        loc = result.end() 
+        ret = result.group() 
+ 
+        if self.unquoteResults: 
+ 
+            # strip off quotes 
+            ret = ret[self.quoteCharLen:-self.endQuoteCharLen] 
+ 
+            if isinstance(ret,basestring): 
+                # replace escaped whitespace 
+                if '\\' in ret and self.convertWhitespaceEscapes: 
+                    ws_map = { 
+                        r'\t' : '\t', 
+                        r'\n' : '\n', 
+                        r'\f' : '\f', 
+                        r'\r' : '\r', 
+                    } 
+                    for wslit,wschar in ws_map.items(): 
+                        ret = ret.replace(wslit, wschar) 
+ 
+                # replace escaped characters 
+                if self.escChar: 
+                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret) 
+ 
+                # replace escaped quotes 
+                if self.escQuote: 
+                    ret = ret.replace(self.escQuote, self.endQuoteChar) 
+ 
+        return loc, ret 
+ 
+    def __str__( self ): 
+        try: 
+            return super(QuotedString,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar) 
+ 
+        return self.strRepr 
+ 
+ 
+class CharsNotIn(Token): 
+    """ 
+    Token for matching words composed of characters I{not} in a given set (will 
+    include whitespace in matched characters if not listed in the provided exclusion set - see example). 
+    Defined with string containing all disallowed characters, and an optional 
+    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a 
+    minimum value < 1 is not valid); the default values for C{max} and C{exact} 
+    are 0, meaning no maximum or exact length restriction. 
+ 
+    Example:: 
+        # define a comma-separated-value as anything that is not a ',' 
+        csv_value = CharsNotIn(',') 
+        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213")) 
+    prints:: 
+        ['dkls', 'lsdkjf', 's12 34', '@!#', '213'] 
+    """ 
+    def __init__( self, notChars, min=1, max=0, exact=0 ): 
+        super(CharsNotIn,self).__init__() 
+        self.skipWhitespace = False 
+        self.notChars = notChars 
+ 
+        if min < 1: 
+            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted") 
+ 
+        self.minLen = min 
+ 
+        if max > 0: 
+            self.maxLen = max 
+        else: 
+            self.maxLen = _MAX_INT 
+ 
+        if exact > 0: 
+            self.maxLen = exact 
+            self.minLen = exact 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayReturnEmpty = ( self.minLen == 0 ) 
+        self.mayIndexError = False 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if instring[loc] in self.notChars: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        start = loc 
+        loc += 1 
+        notchars = self.notChars 
+        maxlen = min( start+self.maxLen, len(instring) ) 
+        while loc < maxlen and \ 
+              (instring[loc] not in notchars): 
+            loc += 1 
+ 
+        if loc - start < self.minLen: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        return loc, instring[start:loc] 
+ 
+    def __str__( self ): 
+        try: 
+            return super(CharsNotIn, self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            if len(self.notChars) > 4: 
+                self.strRepr = "!W:(%s...)" % self.notChars[:4] 
+            else: 
+                self.strRepr = "!W:(%s)" % self.notChars 
+ 
+        return self.strRepr 
+ 
+class White(Token): 
+    """ 
+    Special matching class for matching whitespace.  Normally, whitespace is ignored 
+    by pyparsing grammars.  This class is included when some whitespace structures 
+    are significant.  Define with a string containing the whitespace characters to be 
+    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments, 
+    as defined for the C{L{Word}} class. 
+    """ 
+    whiteStrs = { 
+        " " : "<SPC>", 
+        "\t": "<TAB>", 
+        "\n": "<LF>", 
+        "\r": "<CR>", 
+        "\f": "<FF>", 
+        } 
+    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0): 
+        super(White,self).__init__() 
+        self.matchWhite = ws 
+        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) ) 
+        #~ self.leaveWhitespace() 
+        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite)) 
+        self.mayReturnEmpty = True 
+        self.errmsg = "Expected " + self.name 
+ 
+        self.minLen = min 
+ 
+        if max > 0: 
+            self.maxLen = max 
+        else: 
+            self.maxLen = _MAX_INT 
+ 
+        if exact > 0: 
+            self.maxLen = exact 
+            self.minLen = exact 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if not(instring[ loc ] in self.matchWhite): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+        start = loc 
+        loc += 1 
+        maxloc = start + self.maxLen 
+        maxloc = min( maxloc, len(instring) ) 
+        while loc < maxloc and instring[loc] in self.matchWhite: 
+            loc += 1 
+ 
+        if loc - start < self.minLen: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        return loc, instring[start:loc] 
+ 
+ 
+class _PositionToken(Token): 
+    def __init__( self ): 
+        super(_PositionToken,self).__init__() 
+        self.name=self.__class__.__name__ 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+ 
+class GoToColumn(_PositionToken): 
+    """ 
+    Token to advance to a specific column of input text; useful for tabular report scraping. 
+    """ 
+    def __init__( self, colno ): 
+        super(GoToColumn,self).__init__() 
+        self.col = colno 
+ 
+    def preParse( self, instring, loc ): 
+        if col(loc,instring) != self.col: 
+            instrlen = len(instring) 
+            if self.ignoreExprs: 
+                loc = self._skipIgnorables( instring, loc ) 
+            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col : 
+                loc += 1 
+        return loc 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        thiscol = col( loc, instring ) 
+        if thiscol > self.col: 
+            raise ParseException( instring, loc, "Text not in expected column", self ) 
+        newloc = loc + self.col - thiscol 
+        ret = instring[ loc: newloc ] 
+        return newloc, ret 
+ 
+ 
+class LineStart(_PositionToken): 
+    """ 
+    Matches if current position is at the beginning of a line within the parse string 
+     
+    Example:: 
+     
+        test = '''\ 
+        AAA this line 
+        AAA and this line 
+          AAA but not this one 
+        B AAA and definitely not this one 
+        ''' 
+ 
+        for t in (LineStart() + 'AAA' + restOfLine).searchString(test): 
+            print(t) 
+     
+    Prints:: 
+        ['AAA', ' this line'] 
+        ['AAA', ' and this line']     
+ 
+    """ 
+    def __init__( self ): 
+        super(LineStart,self).__init__() 
+        self.errmsg = "Expected start of line" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if col(loc, instring) == 1: 
+            return loc, [] 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class LineEnd(_PositionToken): 
+    """ 
+    Matches if current position is at the end of a line within the parse string 
+    """ 
+    def __init__( self ): 
+        super(LineEnd,self).__init__() 
+        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") ) 
+        self.errmsg = "Expected end of line" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if loc<len(instring): 
+            if instring[loc] == "\n": 
+                return loc+1, "\n" 
+            else: 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        elif loc == len(instring): 
+            return loc+1, [] 
+        else: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class StringStart(_PositionToken): 
+    """ 
+    Matches if current position is at the beginning of the parse string 
+    """ 
+    def __init__( self ): 
+        super(StringStart,self).__init__() 
+        self.errmsg = "Expected start of text" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if loc != 0: 
+            # see if entire string up to here is just whitespace and ignoreables 
+            if loc != self.preParse( instring, 0 ): 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+class StringEnd(_PositionToken): 
+    """ 
+    Matches if current position is at the end of the parse string 
+    """ 
+    def __init__( self ): 
+        super(StringEnd,self).__init__() 
+        self.errmsg = "Expected end of text" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if loc < len(instring): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+        elif loc == len(instring): 
+            return loc+1, [] 
+        elif loc > len(instring): 
+            return loc, [] 
+        else: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class WordStart(_PositionToken): 
+    """ 
+    Matches if the current position is at the beginning of a Word, and 
+    is not preceded by any character in a given set of C{wordChars} 
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions, 
+    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of 
+    the string being parsed, or at the beginning of a line. 
+    """ 
+    def __init__(self, wordChars = printables): 
+        super(WordStart,self).__init__() 
+        self.wordChars = set(wordChars) 
+        self.errmsg = "Not at the start of a word" 
+ 
+    def parseImpl(self, instring, loc, doActions=True ): 
+        if loc != 0: 
+            if (instring[loc-1] in self.wordChars or 
+                instring[loc] not in self.wordChars): 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+class WordEnd(_PositionToken): 
+    """ 
+    Matches if the current position is at the end of a Word, and 
+    is not followed by any character in a given set of C{wordChars} 
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions, 
+    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of 
+    the string being parsed, or at the end of a line. 
+    """ 
+    def __init__(self, wordChars = printables): 
+        super(WordEnd,self).__init__() 
+        self.wordChars = set(wordChars) 
+        self.skipWhitespace = False 
+        self.errmsg = "Not at the end of a word" 
+ 
+    def parseImpl(self, instring, loc, doActions=True ): 
+        instrlen = len(instring) 
+        if instrlen>0 and loc<instrlen: 
+            if (instring[loc] in self.wordChars or 
+                instring[loc-1] not in self.wordChars): 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+ 
+class ParseExpression(ParserElement): 
+    """ 
+    Abstract subclass of ParserElement, for combining and post-processing parsed tokens. 
+    """ 
+    def __init__( self, exprs, savelist = False ): 
+        super(ParseExpression,self).__init__(savelist) 
+        if isinstance( exprs, _generatorType ): 
+            exprs = list(exprs) 
+ 
+        if isinstance( exprs, basestring ): 
+            self.exprs = [ ParserElement._literalStringClass( exprs ) ] 
+        elif isinstance( exprs, Iterable ): 
+            exprs = list(exprs) 
+            # if sequence of strings provided, wrap with Literal 
+            if all(isinstance(expr, basestring) for expr in exprs): 
+                exprs = map(ParserElement._literalStringClass, exprs) 
+            self.exprs = list(exprs) 
+        else: 
+            try: 
+                self.exprs = list( exprs ) 
+            except TypeError: 
+                self.exprs = [ exprs ] 
+        self.callPreparse = False 
+ 
+    def __getitem__( self, i ): 
+        return self.exprs[i] 
+ 
+    def append( self, other ): 
+        self.exprs.append( other ) 
+        self.strRepr = None 
+        return self 
+ 
+    def leaveWhitespace( self ): 
+        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on 
+           all contained expressions.""" 
+        self.skipWhitespace = False 
+        self.exprs = [ e.copy() for e in self.exprs ] 
+        for e in self.exprs: 
+            e.leaveWhitespace() 
+        return self 
+ 
+    def ignore( self, other ): 
+        if isinstance( other, Suppress ): 
+            if other not in self.ignoreExprs: 
+                super( ParseExpression, self).ignore( other ) 
+                for e in self.exprs: 
+                    e.ignore( self.ignoreExprs[-1] ) 
+        else: 
+            super( ParseExpression, self).ignore( other ) 
+            for e in self.exprs: 
+                e.ignore( self.ignoreExprs[-1] ) 
+        return self 
+ 
+    def __str__( self ): 
+        try: 
+            return super(ParseExpression,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) ) 
+        return self.strRepr 
+ 
+    def streamline( self ): 
+        super(ParseExpression,self).streamline() 
+ 
+        for e in self.exprs: 
+            e.streamline() 
+ 
+        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d ) 
+        # but only if there are no parse actions or resultsNames on the nested And's 
+        # (likewise for Or's and MatchFirst's) 
+        if ( len(self.exprs) == 2 ): 
+            other = self.exprs[0] 
+            if ( isinstance( other, self.__class__ ) and 
+                  not(other.parseAction) and 
+                  other.resultsName is None and 
+                  not other.debug ): 
+                self.exprs = other.exprs[:] + [ self.exprs[1] ] 
+                self.strRepr = None 
+                self.mayReturnEmpty |= other.mayReturnEmpty 
+                self.mayIndexError  |= other.mayIndexError 
+ 
+            other = self.exprs[-1] 
+            if ( isinstance( other, self.__class__ ) and 
+                  not(other.parseAction) and 
+                  other.resultsName is None and 
+                  not other.debug ): 
+                self.exprs = self.exprs[:-1] + other.exprs[:] 
+                self.strRepr = None 
+                self.mayReturnEmpty |= other.mayReturnEmpty 
+                self.mayIndexError  |= other.mayIndexError 
+ 
+        self.errmsg = "Expected " + _ustr(self) 
+         
+        return self 
+ 
+    def setResultsName( self, name, listAllMatches=False ): 
+        ret = super(ParseExpression,self).setResultsName(name,listAllMatches) 
+        return ret 
+ 
+    def validate( self, validateTrace=[] ): 
+        tmp = validateTrace[:]+[self] 
+        for e in self.exprs: 
+            e.validate(tmp) 
+        self.checkRecursion( [] ) 
+         
+    def copy(self): 
+        ret = super(ParseExpression,self).copy() 
+        ret.exprs = [e.copy() for e in self.exprs] 
+        return ret 
+ 
+class And(ParseExpression): 
+    """ 
+    Requires all given C{ParseExpression}s to be found in the given order. 
+    Expressions may be separated by whitespace. 
+    May be constructed using the C{'+'} operator. 
+    May also be constructed using the C{'-'} operator, which will suppress backtracking. 
+ 
+    Example:: 
+        integer = Word(nums) 
+        name_expr = OneOrMore(Word(alphas)) 
+ 
+        expr = And([integer("id"),name_expr("name"),integer("age")]) 
+        # more easily written as: 
+        expr = integer("id") + name_expr("name") + integer("age") 
+    """ 
+ 
+    class _ErrorStop(Empty): 
+        def __init__(self, *args, **kwargs): 
+            super(And._ErrorStop,self).__init__(*args, **kwargs) 
+            self.name = '-' 
+            self.leaveWhitespace() 
+ 
+    def __init__( self, exprs, savelist = True ): 
+        super(And,self).__init__(exprs, savelist) 
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs) 
+        self.setWhitespaceChars( self.exprs[0].whiteChars ) 
+        self.skipWhitespace = self.exprs[0].skipWhitespace 
+        self.callPreparse = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        # pass False as last arg to _parse for first element, since we already 
+        # pre-parsed the string as part of our And pre-parsing 
+        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False ) 
+        errorStop = False 
+        for e in self.exprs[1:]: 
+            if isinstance(e, And._ErrorStop): 
+                errorStop = True 
+                continue 
+            if errorStop: 
+                try: 
+                    loc, exprtokens = e._parse( instring, loc, doActions ) 
+                except ParseSyntaxException: 
+                    raise 
+                except ParseBaseException as pe: 
+                    pe.__traceback__ = None 
+                    raise ParseSyntaxException._from_exception(pe) 
+                except IndexError: 
+                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self) 
+            else: 
+                loc, exprtokens = e._parse( instring, loc, doActions ) 
+            if exprtokens or exprtokens.haskeys(): 
+                resultlist += exprtokens 
+        return loc, resultlist 
+ 
+    def __iadd__(self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        return self.append( other ) #And( [ self, other ] ) 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+            if not e.mayReturnEmpty: 
+                break 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+ 
+class Or(ParseExpression): 
+    """ 
+    Requires that at least one C{ParseExpression} is found. 
+    If two expressions match, the expression that matches the longest string will be used. 
+    May be constructed using the C{'^'} operator. 
+ 
+    Example:: 
+        # construct Or using '^' operator 
+         
+        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums)) 
+        print(number.searchString("123 3.1416 789")) 
+    prints:: 
+        [['123'], ['3.1416'], ['789']] 
+    """ 
+    def __init__( self, exprs, savelist = False ): 
+        super(Or,self).__init__(exprs, savelist) 
+        if self.exprs: 
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs) 
+        else: 
+            self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        maxExcLoc = -1 
+        maxException = None 
+        matches = [] 
+        for e in self.exprs: 
+            try: 
+                loc2 = e.tryParse( instring, loc ) 
+            except ParseException as err: 
+                err.__traceback__ = None 
+                if err.loc > maxExcLoc: 
+                    maxException = err 
+                    maxExcLoc = err.loc 
+            except IndexError: 
+                if len(instring) > maxExcLoc: 
+                    maxException = ParseException(instring,len(instring),e.errmsg,self) 
+                    maxExcLoc = len(instring) 
+            else: 
+                # save match among all matches, to retry longest to shortest 
+                matches.append((loc2, e)) 
+ 
+        if matches: 
+            matches.sort(key=lambda x: -x[0]) 
+            for _,e in matches: 
+                try: 
+                    return e._parse( instring, loc, doActions ) 
+                except ParseException as err: 
+                    err.__traceback__ = None 
+                    if err.loc > maxExcLoc: 
+                        maxException = err 
+                        maxExcLoc = err.loc 
+ 
+        if maxException is not None: 
+            maxException.msg = self.errmsg 
+            raise maxException 
+        else: 
+            raise ParseException(instring, loc, "no defined alternatives to match", self) 
+ 
+ 
+    def __ixor__(self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        return self.append( other ) #Or( [ self, other ] ) 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+ 
+ 
+class MatchFirst(ParseExpression): 
+    """ 
+    Requires that at least one C{ParseExpression} is found. 
+    If two expressions match, the first one listed is the one that will match. 
+    May be constructed using the C{'|'} operator. 
+ 
+    Example:: 
+        # construct MatchFirst using '|' operator 
+         
+        # watch the order of expressions to match 
+        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums)) 
+        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']] 
+ 
+        # put more selective expression first 
+        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums) 
+        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']] 
+    """ 
+    def __init__( self, exprs, savelist = False ): 
+        super(MatchFirst,self).__init__(exprs, savelist) 
+        if self.exprs: 
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs) 
+        else: 
+            self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        maxExcLoc = -1 
+        maxException = None 
+        for e in self.exprs: 
+            try: 
+                ret = e._parse( instring, loc, doActions ) 
+                return ret 
+            except ParseException as err: 
+                if err.loc > maxExcLoc: 
+                    maxException = err 
+                    maxExcLoc = err.loc 
+            except IndexError: 
+                if len(instring) > maxExcLoc: 
+                    maxException = ParseException(instring,len(instring),e.errmsg,self) 
+                    maxExcLoc = len(instring) 
+ 
+        # only got here if no expression matched, raise exception for match that made it the furthest 
+        else: 
+            if maxException is not None: 
+                maxException.msg = self.errmsg 
+                raise maxException 
+            else: 
+                raise ParseException(instring, loc, "no defined alternatives to match", self) 
+ 
+    def __ior__(self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        return self.append( other ) #MatchFirst( [ self, other ] ) 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+ 
+ 
+class Each(ParseExpression): 
+    """ 
+    Requires all given C{ParseExpression}s to be found, but in any order. 
+    Expressions may be separated by whitespace. 
+    May be constructed using the C{'&'} operator. 
+ 
+    Example:: 
+        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN") 
+        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON") 
+        integer = Word(nums) 
+        shape_attr = "shape:" + shape_type("shape") 
+        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn") 
+        color_attr = "color:" + color("color") 
+        size_attr = "size:" + integer("size") 
+ 
+        # use Each (using operator '&') to accept attributes in any order  
+        # (shape and posn are required, color and size are optional) 
+        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr) 
+ 
+        shape_spec.runTests(''' 
+            shape: SQUARE color: BLACK posn: 100, 120 
+            shape: CIRCLE size: 50 color: BLUE posn: 50,80 
+            color:GREEN size:20 shape:TRIANGLE posn:20,40 
+            ''' 
+            ) 
+    prints:: 
+        shape: SQUARE color: BLACK posn: 100, 120 
+        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']] 
+        - color: BLACK 
+        - posn: ['100', ',', '120'] 
+          - x: 100 
+          - y: 120 
+        - shape: SQUARE 
+ 
+ 
+        shape: CIRCLE size: 50 color: BLUE posn: 50,80 
+        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']] 
+        - color: BLUE 
+        - posn: ['50', ',', '80'] 
+          - x: 50 
+          - y: 80 
+        - shape: CIRCLE 
+        - size: 50 
+ 
+ 
+        color: GREEN size: 20 shape: TRIANGLE posn: 20,40 
+        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']] 
+        - color: GREEN 
+        - posn: ['20', ',', '40'] 
+          - x: 20 
+          - y: 40 
+        - shape: TRIANGLE 
+        - size: 20 
+    """ 
+    def __init__( self, exprs, savelist = True ): 
+        super(Each,self).__init__(exprs, savelist) 
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs) 
+        self.skipWhitespace = True 
+        self.initExprGroups = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.initExprGroups: 
+            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional)) 
+            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ] 
+            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)] 
+            self.optionals = opt1 + opt2 
+            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ] 
+            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ] 
+            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ] 
+            self.required += self.multirequired 
+            self.initExprGroups = False 
+        tmpLoc = loc 
+        tmpReqd = self.required[:] 
+        tmpOpt  = self.optionals[:] 
+        matchOrder = [] 
+ 
+        keepMatching = True 
+        while keepMatching: 
+            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired 
+            failed = [] 
+            for e in tmpExprs: 
+                try: 
+                    tmpLoc = e.tryParse( instring, tmpLoc ) 
+                except ParseException: 
+                    failed.append(e) 
+                else: 
+                    matchOrder.append(self.opt1map.get(id(e),e)) 
+                    if e in tmpReqd: 
+                        tmpReqd.remove(e) 
+                    elif e in tmpOpt: 
+                        tmpOpt.remove(e) 
+            if len(failed) == len(tmpExprs): 
+                keepMatching = False 
+ 
+        if tmpReqd: 
+            missing = ", ".join(_ustr(e) for e in tmpReqd) 
+            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing ) 
+ 
+        # add any unmatched Optionals, in case they have default values defined 
+        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt] 
+ 
+        resultlist = [] 
+        for e in matchOrder: 
+            loc,results = e._parse(instring,loc,doActions) 
+            resultlist.append(results) 
+ 
+        finalResults = sum(resultlist, ParseResults([])) 
+        return loc, finalResults 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+ 
+ 
+class ParseElementEnhance(ParserElement): 
+    """ 
+    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens. 
+    """ 
+    def __init__( self, expr, savelist=False ): 
+        super(ParseElementEnhance,self).__init__(savelist) 
+        if isinstance( expr, basestring ): 
+            if issubclass(ParserElement._literalStringClass, Token): 
+                expr = ParserElement._literalStringClass(expr) 
+            else: 
+                expr = ParserElement._literalStringClass(Literal(expr)) 
+        self.expr = expr 
+        self.strRepr = None 
+        if expr is not None: 
+            self.mayIndexError = expr.mayIndexError 
+            self.mayReturnEmpty = expr.mayReturnEmpty 
+            self.setWhitespaceChars( expr.whiteChars ) 
+            self.skipWhitespace = expr.skipWhitespace 
+            self.saveAsList = expr.saveAsList 
+            self.callPreparse = expr.callPreparse 
+            self.ignoreExprs.extend(expr.ignoreExprs) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.expr is not None: 
+            return self.expr._parse( instring, loc, doActions, callPreParse=False ) 
+        else: 
+            raise ParseException("",loc,self.errmsg,self) 
+ 
+    def leaveWhitespace( self ): 
+        self.skipWhitespace = False 
+        self.expr = self.expr.copy() 
+        if self.expr is not None: 
+            self.expr.leaveWhitespace() 
+        return self 
+ 
+    def ignore( self, other ): 
+        if isinstance( other, Suppress ): 
+            if other not in self.ignoreExprs: 
+                super( ParseElementEnhance, self).ignore( other ) 
+                if self.expr is not None: 
+                    self.expr.ignore( self.ignoreExprs[-1] ) 
+        else: 
+            super( ParseElementEnhance, self).ignore( other ) 
+            if self.expr is not None: 
+                self.expr.ignore( self.ignoreExprs[-1] ) 
+        return self 
+ 
+    def streamline( self ): 
+        super(ParseElementEnhance,self).streamline() 
+        if self.expr is not None: 
+            self.expr.streamline() 
+        return self 
+ 
+    def checkRecursion( self, parseElementList ): 
+        if self in parseElementList: 
+            raise RecursiveGrammarException( parseElementList+[self] ) 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        if self.expr is not None: 
+            self.expr.checkRecursion( subRecCheckList ) 
+ 
+    def validate( self, validateTrace=[] ): 
+        tmp = validateTrace[:]+[self] 
+        if self.expr is not None: 
+            self.expr.validate(tmp) 
+        self.checkRecursion( [] ) 
+ 
+    def __str__( self ): 
+        try: 
+            return super(ParseElementEnhance,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None and self.expr is not None: 
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) ) 
+        return self.strRepr 
+ 
+ 
+class FollowedBy(ParseElementEnhance): 
+    """ 
+    Lookahead matching of the given parse expression.  C{FollowedBy} 
+    does I{not} advance the parsing position within the input string, it only 
+    verifies that the specified parse expression matches at the current 
+    position.  C{FollowedBy} always returns a null token list. 
+ 
+    Example:: 
+        # use FollowedBy to match a label only if it is followed by a ':' 
+        data_word = Word(alphas) 
+        label = data_word + FollowedBy(':') 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+         
+        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint() 
+    prints:: 
+        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']] 
+    """ 
+    def __init__( self, expr ): 
+        super(FollowedBy,self).__init__(expr) 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        self.expr.tryParse( instring, loc ) 
+        return loc, [] 
+ 
+ 
+class NotAny(ParseElementEnhance): 
+    """ 
+    Lookahead to disallow matching with the given parse expression.  C{NotAny} 
+    does I{not} advance the parsing position within the input string, it only 
+    verifies that the specified parse expression does I{not} match at the current 
+    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny} 
+    always returns a null token list.  May be constructed using the '~' operator. 
+ 
+    Example:: 
+         
+    """ 
+    def __init__( self, expr ): 
+        super(NotAny,self).__init__(expr) 
+        #~ self.leaveWhitespace() 
+        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs 
+        self.mayReturnEmpty = True 
+        self.errmsg = "Found unwanted token, "+_ustr(self.expr) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.expr.canParseNext(instring, loc): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "~{" + _ustr(self.expr) + "}" 
+ 
+        return self.strRepr 
+ 
+class _MultipleMatch(ParseElementEnhance): 
+    def __init__( self, expr, stopOn=None): 
+        super(_MultipleMatch, self).__init__(expr) 
+        self.saveAsList = True 
+        ender = stopOn 
+        if isinstance(ender, basestring): 
+            ender = ParserElement._literalStringClass(ender) 
+        self.not_ender = ~ender if ender is not None else None 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        self_expr_parse = self.expr._parse 
+        self_skip_ignorables = self._skipIgnorables 
+        check_ender = self.not_ender is not None 
+        if check_ender: 
+            try_not_ender = self.not_ender.tryParse 
+         
+        # must be at least one (but first see if we are the stopOn sentinel; 
+        # if so, fail) 
+        if check_ender: 
+            try_not_ender(instring, loc) 
+        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False ) 
+        try: 
+            hasIgnoreExprs = (not not self.ignoreExprs) 
+            while 1: 
+                if check_ender: 
+                    try_not_ender(instring, loc) 
+                if hasIgnoreExprs: 
+                    preloc = self_skip_ignorables( instring, loc ) 
+                else: 
+                    preloc = loc 
+                loc, tmptokens = self_expr_parse( instring, preloc, doActions ) 
+                if tmptokens or tmptokens.haskeys(): 
+                    tokens += tmptokens 
+        except (ParseException,IndexError): 
+            pass 
+ 
+        return loc, tokens 
+         
+class OneOrMore(_MultipleMatch): 
+    """ 
+    Repetition of one or more of the given expression. 
+     
+    Parameters: 
+     - expr - expression that must match one or more times 
+     - stopOn - (default=C{None}) - expression for a terminating sentinel 
+          (only required if the sentinel would ordinarily match the repetition  
+          expression)           
+ 
+    Example:: 
+        data_word = Word(alphas) 
+        label = data_word + FollowedBy(':') 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) 
+ 
+        text = "shape: SQUARE posn: upper left color: BLACK" 
+        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']] 
+ 
+        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']] 
+         
+        # could also be written as 
+        (attr_expr * (1,)).parseString(text).pprint() 
+    """ 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + _ustr(self.expr) + "}..." 
+ 
+        return self.strRepr 
+ 
+class ZeroOrMore(_MultipleMatch): 
+    """ 
+    Optional repetition of zero or more of the given expression. 
+     
+    Parameters: 
+     - expr - expression that must match zero or more times 
+     - stopOn - (default=C{None}) - expression for a terminating sentinel 
+          (only required if the sentinel would ordinarily match the repetition  
+          expression)           
+ 
+    Example: similar to L{OneOrMore} 
+    """ 
+    def __init__( self, expr, stopOn=None): 
+        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn) 
+        self.mayReturnEmpty = True 
+         
+    def parseImpl( self, instring, loc, doActions=True ): 
+        try: 
+            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions) 
+        except (ParseException,IndexError): 
+            return loc, [] 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "[" + _ustr(self.expr) + "]..." 
+ 
+        return self.strRepr 
+ 
+class _NullToken(object): 
+    def __bool__(self): 
+        return False 
+    __nonzero__ = __bool__ 
+    def __str__(self): 
+        return "" 
+ 
+_optionalNotMatched = _NullToken() 
+class Optional(ParseElementEnhance): 
+    """ 
+    Optional matching of the given expression. 
+ 
+    Parameters: 
+     - expr - expression that must match zero or more times 
+     - default (optional) - value to be returned if the optional expression is not found. 
+ 
+    Example:: 
+        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier 
+        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4))) 
+        zip.runTests(''' 
+            # traditional ZIP code 
+            12345 
+             
+            # ZIP+4 form 
+            12101-0001 
+             
+            # invalid ZIP 
+            98765- 
+            ''') 
+    prints:: 
+        # traditional ZIP code 
+        12345 
+        ['12345'] 
+ 
+        # ZIP+4 form 
+        12101-0001 
+        ['12101-0001'] 
+ 
+        # invalid ZIP 
+        98765- 
+             ^ 
+        FAIL: Expected end of text (at char 5), (line:1, col:6) 
+    """ 
+    def __init__( self, expr, default=_optionalNotMatched ): 
+        super(Optional,self).__init__( expr, savelist=False ) 
+        self.saveAsList = self.expr.saveAsList 
+        self.defaultValue = default 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        try: 
+            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False ) 
+        except (ParseException,IndexError): 
+            if self.defaultValue is not _optionalNotMatched: 
+                if self.expr.resultsName: 
+                    tokens = ParseResults([ self.defaultValue ]) 
+                    tokens[self.expr.resultsName] = self.defaultValue 
+                else: 
+                    tokens = [ self.defaultValue ] 
+            else: 
+                tokens = [] 
+        return loc, tokens 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "[" + _ustr(self.expr) + "]" 
+ 
+        return self.strRepr 
+ 
+class SkipTo(ParseElementEnhance): 
+    """ 
+    Token for skipping over all undefined text until the matched expression is found. 
+ 
+    Parameters: 
+     - expr - target expression marking the end of the data to be skipped 
+     - include - (default=C{False}) if True, the target expression is also parsed  
+          (the skipped text and target expression are returned as a 2-element list). 
+     - ignore - (default=C{None}) used to define grammars (typically quoted strings and  
+          comments) that might contain false matches to the target expression 
+     - failOn - (default=C{None}) define expressions that are not allowed to be  
+          included in the skipped test; if found before the target expression is found,  
+          the SkipTo is not a match 
+ 
+    Example:: 
+        report = ''' 
+            Outstanding Issues Report - 1 Jan 2000 
+ 
+               # | Severity | Description                               |  Days Open 
+            -----+----------+-------------------------------------------+----------- 
+             101 | Critical | Intermittent system crash                 |          6 
+              94 | Cosmetic | Spelling error on Login ('log|n')         |         14 
+              79 | Minor    | System slow when running too many reports |         47 
+            ''' 
+        integer = Word(nums) 
+        SEP = Suppress('|') 
+        # use SkipTo to simply match everything up until the next SEP 
+        # - ignore quoted strings, so that a '|' character inside a quoted string does not match 
+        # - parse action will call token.strip() for each matched token, i.e., the description body 
+        string_data = SkipTo(SEP, ignore=quotedString) 
+        string_data.setParseAction(tokenMap(str.strip)) 
+        ticket_expr = (integer("issue_num") + SEP  
+                      + string_data("sev") + SEP  
+                      + string_data("desc") + SEP  
+                      + integer("days_open")) 
+         
+        for tkt in ticket_expr.searchString(report): 
+            print tkt.dump() 
+    prints:: 
+        ['101', 'Critical', 'Intermittent system crash', '6'] 
+        - days_open: 6 
+        - desc: Intermittent system crash 
+        - issue_num: 101 
+        - sev: Critical 
+        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14'] 
+        - days_open: 14 
+        - desc: Spelling error on Login ('log|n') 
+        - issue_num: 94 
+        - sev: Cosmetic 
+        ['79', 'Minor', 'System slow when running too many reports', '47'] 
+        - days_open: 47 
+        - desc: System slow when running too many reports 
+        - issue_num: 79 
+        - sev: Minor 
+    """ 
+    def __init__( self, other, include=False, ignore=None, failOn=None ): 
+        super( SkipTo, self ).__init__( other ) 
+        self.ignoreExpr = ignore 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+        self.includeMatch = include 
+        self.asList = False 
+        if isinstance(failOn, basestring): 
+            self.failOn = ParserElement._literalStringClass(failOn) 
+        else: 
+            self.failOn = failOn 
+        self.errmsg = "No match found for "+_ustr(self.expr) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        startloc = loc 
+        instrlen = len(instring) 
+        expr = self.expr 
+        expr_parse = self.expr._parse 
+        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None 
+        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None 
+         
+        tmploc = loc 
+        while tmploc <= instrlen: 
+            if self_failOn_canParseNext is not None: 
+                # break if failOn expression matches 
+                if self_failOn_canParseNext(instring, tmploc): 
+                    break 
+                     
+            if self_ignoreExpr_tryParse is not None: 
+                # advance past ignore expressions 
+                while 1: 
+                    try: 
+                        tmploc = self_ignoreExpr_tryParse(instring, tmploc) 
+                    except ParseBaseException: 
+                        break 
+             
+            try: 
+                expr_parse(instring, tmploc, doActions=False, callPreParse=False) 
+            except (ParseException, IndexError): 
+                # no match, advance loc in string 
+                tmploc += 1 
+            else: 
+                # matched skipto expr, done 
+                break 
+ 
+        else: 
+            # ran off the end of the input string without matching skipto expr, fail 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        # build up return values 
+        loc = tmploc 
+        skiptext = instring[startloc:loc] 
+        skipresult = ParseResults(skiptext) 
+         
+        if self.includeMatch: 
+            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False) 
+            skipresult += mat 
+ 
+        return loc, skipresult 
+ 
+class Forward(ParseElementEnhance): 
+    """ 
+    Forward declaration of an expression to be defined later - 
+    used for recursive grammars, such as algebraic infix notation. 
+    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator. 
+ 
+    Note: take care when assigning to C{Forward} not to overlook precedence of operators. 
+    Specifically, '|' has a lower precedence than '<<', so that:: 
+        fwdExpr << a | b | c 
+    will actually be evaluated as:: 
+        (fwdExpr << a) | b | c 
+    thereby leaving b and c out as parseable alternatives.  It is recommended that you 
+    explicitly group the values inserted into the C{Forward}:: 
+        fwdExpr << (a | b | c) 
+    Converting to use the '<<=' operator instead will avoid this problem. 
+ 
+    See L{ParseResults.pprint} for an example of a recursive parser created using 
+    C{Forward}. 
+    """ 
+    def __init__( self, other=None ): 
+        super(Forward,self).__init__( other, savelist=False ) 
+ 
+    def __lshift__( self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass(other) 
+        self.expr = other 
+        self.strRepr = None 
+        self.mayIndexError = self.expr.mayIndexError 
+        self.mayReturnEmpty = self.expr.mayReturnEmpty 
+        self.setWhitespaceChars( self.expr.whiteChars ) 
+        self.skipWhitespace = self.expr.skipWhitespace 
+        self.saveAsList = self.expr.saveAsList 
+        self.ignoreExprs.extend(self.expr.ignoreExprs) 
+        return self 
+         
+    def __ilshift__(self, other): 
+        return self << other 
+     
+    def leaveWhitespace( self ): 
+        self.skipWhitespace = False 
+        return self 
+ 
+    def streamline( self ): 
+        if not self.streamlined: 
+            self.streamlined = True 
+            if self.expr is not None: 
+                self.expr.streamline() 
+        return self 
+ 
+    def validate( self, validateTrace=[] ): 
+        if self not in validateTrace: 
+            tmp = validateTrace[:]+[self] 
+            if self.expr is not None: 
+                self.expr.validate(tmp) 
+        self.checkRecursion([]) 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+        return self.__class__.__name__ + ": ..." 
+ 
+        # stubbed out for now - creates awful memory and perf issues 
+        self._revertClass = self.__class__ 
+        self.__class__ = _ForwardNoRecurse 
+        try: 
+            if self.expr is not None: 
+                retString = _ustr(self.expr) 
+            else: 
+                retString = "None" 
+        finally: 
+            self.__class__ = self._revertClass 
+        return self.__class__.__name__ + ": " + retString 
+ 
+    def copy(self): 
+        if self.expr is not None: 
+            return super(Forward,self).copy() 
+        else: 
+            ret = Forward() 
+            ret <<= self 
+            return ret 
+ 
+class _ForwardNoRecurse(Forward): 
+    def __str__( self ): 
+        return "..." 
+ 
+class TokenConverter(ParseElementEnhance): 
+    """ 
+    Abstract subclass of C{ParseExpression}, for converting parsed results. 
+    """ 
+    def __init__( self, expr, savelist=False ): 
+        super(TokenConverter,self).__init__( expr )#, savelist ) 
+        self.saveAsList = False 
+ 
+class Combine(TokenConverter): 
+    """ 
+    Converter to concatenate all matching tokens to a single string. 
+    By default, the matching patterns must also be contiguous in the input string; 
+    this can be disabled by specifying C{'adjacent=False'} in the constructor. 
+ 
+    Example:: 
+        real = Word(nums) + '.' + Word(nums) 
+        print(real.parseString('3.1416')) # -> ['3', '.', '1416'] 
+        # will also erroneously match the following 
+        print(real.parseString('3. 1416')) # -> ['3', '.', '1416'] 
+ 
+        real = Combine(Word(nums) + '.' + Word(nums)) 
+        print(real.parseString('3.1416')) # -> ['3.1416'] 
+        # no match when there are internal spaces 
+        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...) 
+    """ 
+    def __init__( self, expr, joinString="", adjacent=True ): 
+        super(Combine,self).__init__( expr ) 
+        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself 
+        if adjacent: 
+            self.leaveWhitespace() 
+        self.adjacent = adjacent 
+        self.skipWhitespace = True 
+        self.joinString = joinString 
+        self.callPreparse = True 
+ 
+    def ignore( self, other ): 
+        if self.adjacent: 
+            ParserElement.ignore(self, other) 
+        else: 
+            super( Combine, self).ignore( other ) 
+        return self 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        retToks = tokenlist.copy() 
+        del retToks[:] 
+        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults) 
+ 
+        if self.resultsName and retToks.haskeys(): 
+            return [ retToks ] 
+        else: 
+            return retToks 
+ 
+class Group(TokenConverter): 
+    """ 
+    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions. 
+ 
+    Example:: 
+        ident = Word(alphas) 
+        num = Word(nums) 
+        term = ident | num 
+        func = ident + Optional(delimitedList(term)) 
+        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100'] 
+ 
+        func = ident + Group(Optional(delimitedList(term))) 
+        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']] 
+    """ 
+    def __init__( self, expr ): 
+        super(Group,self).__init__( expr ) 
+        self.saveAsList = True 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        return [ tokenlist ] 
+ 
+class Dict(TokenConverter): 
+    """ 
+    Converter to return a repetitive expression as a list, but also as a dictionary. 
+    Each element can also be referenced using the first token in the expression as its key. 
+    Useful for tabular report scraping when the first column can be used as a item key. 
+ 
+    Example:: 
+        data_word = Word(alphas) 
+        label = data_word + FollowedBy(':') 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) 
+ 
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap" 
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+         
+        # print attributes as plain groups 
+        print(OneOrMore(attr_expr).parseString(text).dump()) 
+         
+        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names 
+        result = Dict(OneOrMore(Group(attr_expr))).parseString(text) 
+        print(result.dump()) 
+         
+        # access named fields as dict entries, or output as dict 
+        print(result['shape'])         
+        print(result.asDict()) 
+    prints:: 
+        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap'] 
+ 
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] 
+        - color: light blue 
+        - posn: upper left 
+        - shape: SQUARE 
+        - texture: burlap 
+        SQUARE 
+        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'} 
+    See more examples at L{ParseResults} of accessing fields by results name. 
+    """ 
+    def __init__( self, expr ): 
+        super(Dict,self).__init__( expr ) 
+        self.saveAsList = True 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        for i,tok in enumerate(tokenlist): 
+            if len(tok) == 0: 
+                continue 
+            ikey = tok[0] 
+            if isinstance(ikey,int): 
+                ikey = _ustr(tok[0]).strip() 
+            if len(tok)==1: 
+                tokenlist[ikey] = _ParseResultsWithOffset("",i) 
+            elif len(tok)==2 and not isinstance(tok[1],ParseResults): 
+                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i) 
+            else: 
+                dictvalue = tok.copy() #ParseResults(i) 
+                del dictvalue[0] 
+                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()): 
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i) 
+                else: 
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i) 
+ 
+        if self.resultsName: 
+            return [ tokenlist ] 
+        else: 
+            return tokenlist 
+ 
+ 
+class Suppress(TokenConverter): 
+    """ 
+    Converter for ignoring the results of a parsed expression. 
+ 
+    Example:: 
+        source = "a, b, c,d" 
+        wd = Word(alphas) 
+        wd_list1 = wd + ZeroOrMore(',' + wd) 
+        print(wd_list1.parseString(source)) 
+ 
+        # often, delimiters that are useful during parsing are just in the 
+        # way afterward - use Suppress to keep them out of the parsed output 
+        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd) 
+        print(wd_list2.parseString(source)) 
+    prints:: 
+        ['a', ',', 'b', ',', 'c', ',', 'd'] 
+        ['a', 'b', 'c', 'd'] 
+    (See also L{delimitedList}.) 
+    """ 
+    def postParse( self, instring, loc, tokenlist ): 
+        return [] 
+ 
+    def suppress( self ): 
+        return self 
+ 
+ 
+class OnlyOnce(object): 
+    """ 
+    Wrapper for parse actions, to ensure they are only called once. 
+    """ 
+    def __init__(self, methodCall): 
+        self.callable = _trim_arity(methodCall) 
+        self.called = False 
+    def __call__(self,s,l,t): 
+        if not self.called: 
+            results = self.callable(s,l,t) 
+            self.called = True 
+            return results 
+        raise ParseException(s,l,"") 
+    def reset(self): 
+        self.called = False 
+ 
+def traceParseAction(f): 
+    """ 
+    Decorator for debugging parse actions.  
+     
+    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".} 
+    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised. 
+ 
+    Example:: 
+        wd = Word(alphas) 
+ 
+        @traceParseAction 
+        def remove_duplicate_chars(tokens): 
+            return ''.join(sorted(set(''.join(tokens)))) 
+ 
+        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars) 
+        print(wds.parseString("slkdjs sld sldd sdlf sdljf")) 
+    prints:: 
+        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {})) 
+        <<leaving remove_duplicate_chars (ret: 'dfjkls') 
+        ['dfjkls'] 
+    """ 
+    f = _trim_arity(f) 
+    def z(*paArgs): 
+        thisFunc = f.__name__ 
+        s,l,t = paArgs[-3:] 
+        if len(paArgs)>3: 
+            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc 
+        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) ) 
+        try: 
+            ret = f(*paArgs) 
+        except Exception as exc: 
+            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) ) 
+            raise 
+        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) ) 
+        return ret 
+    try: 
+        z.__name__ = f.__name__ 
+    except AttributeError: 
+        pass 
+    return z 
+ 
+# 
+# global helpers 
+# 
+def delimitedList( expr, delim=",", combine=False ): 
+    """ 
+    Helper to define a delimited list of expressions - the delimiter defaults to ','. 
+    By default, the list elements and delimiters can have intervening whitespace, and 
+    comments, but this can be overridden by passing C{combine=True} in the constructor. 
+    If C{combine} is set to C{True}, the matching tokens are returned as a single token 
+    string, with the delimiters included; otherwise, the matching tokens are returned 
+    as a list of tokens, with the delimiters suppressed. 
+ 
+    Example:: 
+        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc'] 
+        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE'] 
+    """ 
+    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..." 
+    if combine: 
+        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName) 
+    else: 
+        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName) 
+ 
+def countedArray( expr, intExpr=None ): 
+    """ 
+    Helper to define a counted list of expressions. 
+    This helper defines a pattern of the form:: 
+        integer expr expr expr... 
+    where the leading integer tells how many expr expressions follow. 
+    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed. 
+     
+    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value. 
+ 
+    Example:: 
+        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd'] 
+ 
+        # in this parser, the leading integer value is given in binary, 
+        # '10' indicating that 2 values are in the array 
+        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2)) 
+        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd'] 
+    """ 
+    arrayExpr = Forward() 
+    def countFieldParseAction(s,l,t): 
+        n = t[0] 
+        arrayExpr << (n and Group(And([expr]*n)) or Group(empty)) 
+        return [] 
+    if intExpr is None: 
+        intExpr = Word(nums).setParseAction(lambda t:int(t[0])) 
+    else: 
+        intExpr = intExpr.copy() 
+    intExpr.setName("arrayLen") 
+    intExpr.addParseAction(countFieldParseAction, callDuringTry=True) 
+    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...') 
+ 
+def _flatten(L): 
+    ret = [] 
+    for i in L: 
+        if isinstance(i,list): 
+            ret.extend(_flatten(i)) 
+        else: 
+            ret.append(i) 
+    return ret 
+ 
+def matchPreviousLiteral(expr): 
+    """ 
+    Helper to define an expression that is indirectly defined from 
+    the tokens matched in a previous expression, that is, it looks 
+    for a 'repeat' of a previous expression.  For example:: 
+        first = Word(nums) 
+        second = matchPreviousLiteral(first) 
+        matchExpr = first + ":" + second 
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a 
+    previous literal, will also match the leading C{"1:1"} in C{"1:10"}. 
+    If this is not desired, use C{matchPreviousExpr}. 
+    Do I{not} use with packrat parsing enabled. 
+    """ 
+    rep = Forward() 
+    def copyTokenToRepeater(s,l,t): 
+        if t: 
+            if len(t) == 1: 
+                rep << t[0] 
+            else: 
+                # flatten t tokens 
+                tflat = _flatten(t.asList()) 
+                rep << And(Literal(tt) for tt in tflat) 
+        else: 
+            rep << Empty() 
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True) 
+    rep.setName('(prev) ' + _ustr(expr)) 
+    return rep 
+ 
+def matchPreviousExpr(expr): 
+    """ 
+    Helper to define an expression that is indirectly defined from 
+    the tokens matched in a previous expression, that is, it looks 
+    for a 'repeat' of a previous expression.  For example:: 
+        first = Word(nums) 
+        second = matchPreviousExpr(first) 
+        matchExpr = first + ":" + second 
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by 
+    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"}; 
+    the expressions are evaluated first, and then compared, so 
+    C{"1"} is compared with C{"10"}. 
+    Do I{not} use with packrat parsing enabled. 
+    """ 
+    rep = Forward() 
+    e2 = expr.copy() 
+    rep <<= e2 
+    def copyTokenToRepeater(s,l,t): 
+        matchTokens = _flatten(t.asList()) 
+        def mustMatchTheseTokens(s,l,t): 
+            theseTokens = _flatten(t.asList()) 
+            if  theseTokens != matchTokens: 
+                raise ParseException("",0,"") 
+        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True ) 
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True) 
+    rep.setName('(prev) ' + _ustr(expr)) 
+    return rep 
+ 
+def _escapeRegexRangeChars(s): 
+    #~  escape these chars: ^-] 
+    for c in r"\^-]": 
+        s = s.replace(c,_bslash+c) 
+    s = s.replace("\n",r"\n") 
+    s = s.replace("\t",r"\t") 
+    return _ustr(s) 
+ 
+def oneOf( strs, caseless=False, useRegex=True ): 
+    """ 
+    Helper to quickly define a set of alternative Literals, and makes sure to do 
+    longest-first testing when there is a conflict, regardless of the input order, 
+    but returns a C{L{MatchFirst}} for best performance. 
+ 
+    Parameters: 
+     - strs - a string of space-delimited literals, or a collection of string literals 
+     - caseless - (default=C{False}) - treat all literals as caseless 
+     - useRegex - (default=C{True}) - as an optimization, will generate a Regex 
+          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or 
+          if creating a C{Regex} raises an exception) 
+ 
+    Example:: 
+        comp_oper = oneOf("< = > <= >= !=") 
+        var = Word(alphas) 
+        number = Word(nums) 
+        term = var | number 
+        comparison_expr = term + comp_oper + term 
+        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12")) 
+    prints:: 
+        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']] 
+    """ 
+    if caseless: 
+        isequal = ( lambda a,b: a.upper() == b.upper() ) 
+        masks = ( lambda a,b: b.upper().startswith(a.upper()) ) 
+        parseElementClass = CaselessLiteral 
+    else: 
+        isequal = ( lambda a,b: a == b ) 
+        masks = ( lambda a,b: b.startswith(a) ) 
+        parseElementClass = Literal 
+ 
+    symbols = [] 
+    if isinstance(strs,basestring): 
+        symbols = strs.split() 
+    elif isinstance(strs, Iterable): 
+        symbols = list(strs) 
+    else: 
+        warnings.warn("Invalid argument to oneOf, expected string or iterable", 
+                SyntaxWarning, stacklevel=2) 
+    if not symbols: 
+        return NoMatch() 
+ 
+    i = 0 
+    while i < len(symbols)-1: 
+        cur = symbols[i] 
+        for j,other in enumerate(symbols[i+1:]): 
+            if ( isequal(other, cur) ): 
+                del symbols[i+j+1] 
+                break 
+            elif ( masks(cur, other) ): 
+                del symbols[i+j+1] 
+                symbols.insert(i,other) 
+                cur = other 
+                break 
+        else: 
+            i += 1 
+ 
+    if not caseless and useRegex: 
+        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] )) 
+        try: 
+            if len(symbols)==len("".join(symbols)): 
+                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols)) 
+            else: 
+                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols)) 
+        except Exception: 
+            warnings.warn("Exception creating Regex for oneOf, building MatchFirst", 
+                    SyntaxWarning, stacklevel=2) 
+ 
+ 
+    # last resort, just use MatchFirst 
+    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols)) 
+ 
+def dictOf( key, value ): 
+    """ 
+    Helper to easily and clearly define a dictionary by specifying the respective patterns 
+    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens 
+    in the proper order.  The key pattern can include delimiting markers or punctuation, 
+    as long as they are suppressed, thereby leaving the significant key text.  The value 
+    pattern can include named results, so that the C{Dict} results can include named token 
+    fields. 
+ 
+    Example:: 
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap" 
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+        print(OneOrMore(attr_expr).parseString(text).dump()) 
+         
+        attr_label = label 
+        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join) 
+ 
+        # similar to Dict, but simpler call format 
+        result = dictOf(attr_label, attr_value).parseString(text) 
+        print(result.dump()) 
+        print(result['shape']) 
+        print(result.shape)  # object attribute access works too 
+        print(result.asDict()) 
+    prints:: 
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] 
+        - color: light blue 
+        - posn: upper left 
+        - shape: SQUARE 
+        - texture: burlap 
+        SQUARE 
+        SQUARE 
+        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'} 
+    """ 
+    return Dict( ZeroOrMore( Group ( key + value ) ) ) 
+ 
+def originalTextFor(expr, asString=True): 
+    """ 
+    Helper to return the original, untokenized text for a given expression.  Useful to 
+    restore the parsed fields of an HTML start tag into the raw tag text itself, or to 
+    revert separate tokens with intervening whitespace back to the original matching 
+    input text. By default, returns astring containing the original parsed text.   
+        
+    If the optional C{asString} argument is passed as C{False}, then the return value is a  
+    C{L{ParseResults}} containing any results names that were originally matched, and a  
+    single token containing the original matched text from the input string.  So if  
+    the expression passed to C{L{originalTextFor}} contains expressions with defined 
+    results names, you must set C{asString} to C{False} if you want to preserve those 
+    results name values. 
+ 
+    Example:: 
+        src = "this is test <b> bold <i>text</i> </b> normal text " 
+        for tag in ("b","i"): 
+            opener,closer = makeHTMLTags(tag) 
+            patt = originalTextFor(opener + SkipTo(closer) + closer) 
+            print(patt.searchString(src)[0]) 
+    prints:: 
+        ['<b> bold <i>text</i> </b>'] 
+        ['<i>text</i>'] 
+    """ 
+    locMarker = Empty().setParseAction(lambda s,loc,t: loc) 
+    endlocMarker = locMarker.copy() 
+    endlocMarker.callPreparse = False 
+    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end") 
+    if asString: 
+        extractText = lambda s,l,t: s[t._original_start:t._original_end] 
+    else: 
+        def extractText(s,l,t): 
+            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]] 
+    matchExpr.setParseAction(extractText) 
+    matchExpr.ignoreExprs = expr.ignoreExprs 
+    return matchExpr 
+ 
+def ungroup(expr):  
+    """ 
+    Helper to undo pyparsing's default grouping of And expressions, even 
+    if all but one are non-empty. 
+    """ 
+    return TokenConverter(expr).setParseAction(lambda t:t[0]) 
+ 
+def locatedExpr(expr): 
+    """ 
+    Helper to decorate a returned token with its starting and ending locations in the input string. 
+    This helper adds the following results names: 
+     - locn_start = location where matched expression begins 
+     - locn_end = location where matched expression ends 
+     - value = the actual parsed results 
+ 
+    Be careful if the input text contains C{<TAB>} characters, you may want to call 
+    C{L{ParserElement.parseWithTabs}} 
+ 
+    Example:: 
+        wd = Word(alphas) 
+        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"): 
+            print(match) 
+    prints:: 
+        [[0, 'ljsdf', 5]] 
+        [[8, 'lksdjjf', 15]] 
+        [[18, 'lkkjj', 23]] 
+    """ 
+    locator = Empty().setParseAction(lambda s,l,t: l) 
+    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end")) 
+ 
+ 
+# convenience constants for positional expressions 
+empty       = Empty().setName("empty") 
+lineStart   = LineStart().setName("lineStart") 
+lineEnd     = LineEnd().setName("lineEnd") 
+stringStart = StringStart().setName("stringStart") 
+stringEnd   = StringEnd().setName("stringEnd") 
+ 
+_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1]) 
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16))) 
+_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8))) 
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1) 
+_charRange = Group(_singleChar + Suppress("-") + _singleChar) 
+_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]" 
+ 
+def srange(s): 
+    r""" 
+    Helper to easily define string ranges for use in Word construction.  Borrows 
+    syntax from regexp '[]' string range definitions:: 
+        srange("[0-9]")   -> "0123456789" 
+        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz" 
+        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_" 
+    The input string must be enclosed in []'s, and the returned string is the expanded 
+    character set joined into a single string. 
+    The values enclosed in the []'s may be: 
+     - a single character 
+     - an escaped character with a leading backslash (such as C{\-} or C{\]}) 
+     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character)  
+         (C{\0x##} is also supported for backwards compatibility)  
+     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character) 
+     - a range of any of the above, separated by a dash (C{'a-z'}, etc.) 
+     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.) 
+    """ 
+    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1)) 
+    try: 
+        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body) 
+    except Exception: 
+        return "" 
+ 
+def matchOnlyAtCol(n): 
+    """ 
+    Helper method for defining parse actions that require matching at a specific 
+    column in the input text. 
+    """ 
+    def verifyCol(strg,locn,toks): 
+        if col(locn,strg) != n: 
+            raise ParseException(strg,locn,"matched token not at column %d" % n) 
+    return verifyCol 
+ 
+def replaceWith(replStr): 
+    """ 
+    Helper method for common parse actions that simply return a literal value.  Especially 
+    useful when used with C{L{transformString<ParserElement.transformString>}()}. 
+ 
+    Example:: 
+        num = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan)) 
+        term = na | num 
+         
+        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234] 
+    """ 
+    return lambda s,l,t: [replStr] 
+ 
+def removeQuotes(s,l,t): 
+    """ 
+    Helper parse action for removing quotation marks from parsed quoted strings. 
+ 
+    Example:: 
+        # by default, quotation marks are included in parsed results 
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"] 
+ 
+        # use removeQuotes to strip quotation marks from parsed results 
+        quotedString.setParseAction(removeQuotes) 
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"] 
+    """ 
+    return t[0][1:-1] 
+ 
+def tokenMap(func, *args): 
+    """ 
+    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional  
+    args are passed, they are forwarded to the given function as additional arguments after 
+    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the 
+    parsed data to an integer using base 16. 
+ 
+    Example (compare the last to example in L{ParserElement.transformString}:: 
+        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16)) 
+        hex_ints.runTests(''' 
+            00 11 22 aa FF 0a 0d 1a 
+            ''') 
+         
+        upperword = Word(alphas).setParseAction(tokenMap(str.upper)) 
+        OneOrMore(upperword).runTests(''' 
+            my kingdom for a horse 
+            ''') 
+ 
+        wd = Word(alphas).setParseAction(tokenMap(str.title)) 
+        OneOrMore(wd).setParseAction(' '.join).runTests(''' 
+            now is the winter of our discontent made glorious summer by this sun of york 
+            ''') 
+    prints:: 
+        00 11 22 aa FF 0a 0d 1a 
+        [0, 17, 34, 170, 255, 10, 13, 26] 
+ 
+        my kingdom for a horse 
+        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE'] 
+ 
+        now is the winter of our discontent made glorious summer by this sun of york 
+        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York'] 
+    """ 
+    def pa(s,l,t): 
+        return [func(tokn, *args) for tokn in t] 
+ 
+    try: 
+        func_name = getattr(func, '__name__',  
+                            getattr(func, '__class__').__name__) 
+    except Exception: 
+        func_name = str(func) 
+    pa.__name__ = func_name 
+ 
+    return pa 
+ 
+upcaseTokens = tokenMap(lambda t: _ustr(t).upper()) 
+"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}""" 
+ 
+downcaseTokens = tokenMap(lambda t: _ustr(t).lower()) 
+"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}""" 
+     
+def _makeTags(tagStr, xml): 
+    """Internal helper to construct opening and closing tag expressions, given a tag name""" 
+    if isinstance(tagStr,basestring): 
+        resname = tagStr 
+        tagStr = Keyword(tagStr, caseless=not xml) 
+    else: 
+        resname = tagStr.name 
+ 
+    tagAttrName = Word(alphas,alphanums+"_-:") 
+    if (xml): 
+        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes ) 
+        openTag = Suppress("<") + tagStr("tag") + \ 
+                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \ 
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">") 
+    else: 
+        printablesLessRAbrack = "".join(c for c in printables if c not in ">") 
+        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack) 
+        openTag = Suppress("<") + tagStr("tag") + \ 
+                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \ 
+                Optional( Suppress("=") + tagAttrValue ) ))) + \ 
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">") 
+    closeTag = Combine(_L("</") + tagStr + ">") 
+ 
+    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname) 
+    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname) 
+    openTag.tag = resname 
+    closeTag.tag = resname 
+    return openTag, closeTag 
+ 
+def makeHTMLTags(tagStr): 
+    """ 
+    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches 
+    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values. 
+ 
+    Example:: 
+        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>' 
+        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple 
+        a,a_end = makeHTMLTags("A") 
+        link_expr = a + SkipTo(a_end)("link_text") + a_end 
+         
+        for link in link_expr.searchString(text): 
+            # attributes in the <A> tag (like "href" shown here) are also accessible as named results 
+            print(link.link_text, '->', link.href) 
+    prints:: 
+        pyparsing -> http://pyparsing.wikispaces.com 
+    """ 
+    return _makeTags( tagStr, False ) 
+ 
+def makeXMLTags(tagStr): 
+    """ 
+    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches 
+    tags only in the given upper/lower case. 
+ 
+    Example: similar to L{makeHTMLTags} 
+    """ 
+    return _makeTags( tagStr, True ) 
+ 
+def withAttribute(*args,**attrDict): 
+    """ 
+    Helper to create a validating parse action to be used with start tags created 
+    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag 
+    with a required attribute value, to avoid false matches on common tags such as 
+    C{<TD>} or C{<DIV>}. 
+ 
+    Call C{withAttribute} with a series of attribute names and values. Specify the list 
+    of filter attributes names and values as: 
+     - keyword arguments, as in C{(align="right")}, or 
+     - as an explicit dict with C{**} operator, when an attribute name is also a Python 
+          reserved word, as in C{**{"class":"Customer", "align":"right"}} 
+     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") ) 
+    For attribute names with a namespace prefix, you must use the second form.  Attribute 
+    names are matched insensitive to upper/lower case. 
+        
+    If just testing for C{class} (with or without a namespace), use C{L{withClass}}. 
+ 
+    To verify that the attribute exists, but without specifying a value, pass 
+    C{withAttribute.ANY_VALUE} as the value. 
+ 
+    Example:: 
+        html = ''' 
+            <div> 
+            Some text 
+            <div type="grid">1 4 0 1 0</div> 
+            <div type="graph">1,3 2,3 1,1</div> 
+            <div>this has no type</div> 
+            </div> 
+                 
+        ''' 
+        div,div_end = makeHTMLTags("div") 
+ 
+        # only match div tag having a type attribute with value "grid" 
+        div_grid = div().setParseAction(withAttribute(type="grid")) 
+        grid_expr = div_grid + SkipTo(div | div_end)("body") 
+        for grid_header in grid_expr.searchString(html): 
+            print(grid_header.body) 
+         
+        # construct a match with any div tag having a type attribute, regardless of the value 
+        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE)) 
+        div_expr = div_any_type + SkipTo(div | div_end)("body") 
+        for div_header in div_expr.searchString(html): 
+            print(div_header.body) 
+    prints:: 
+        1 4 0 1 0 
+ 
+        1 4 0 1 0 
+        1,3 2,3 1,1 
+    """ 
+    if args: 
+        attrs = args[:] 
+    else: 
+        attrs = attrDict.items() 
+    attrs = [(k,v) for k,v in attrs] 
+    def pa(s,l,tokens): 
+        for attrName,attrValue in attrs: 
+            if attrName not in tokens: 
+                raise ParseException(s,l,"no matching attribute " + attrName) 
+            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue: 
+                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" % 
+                                            (attrName, tokens[attrName], attrValue)) 
+    return pa 
+withAttribute.ANY_VALUE = object() 
+ 
+def withClass(classname, namespace=''): 
+    """ 
+    Simplified version of C{L{withAttribute}} when matching on a div class - made 
+    difficult because C{class} is a reserved word in Python. 
+ 
+    Example:: 
+        html = ''' 
+            <div> 
+            Some text 
+            <div class="grid">1 4 0 1 0</div> 
+            <div class="graph">1,3 2,3 1,1</div> 
+            <div>this &lt;div&gt; has no class</div> 
+            </div> 
+                 
+        ''' 
+        div,div_end = makeHTMLTags("div") 
+        div_grid = div().setParseAction(withClass("grid")) 
+         
+        grid_expr = div_grid + SkipTo(div | div_end)("body") 
+        for grid_header in grid_expr.searchString(html): 
+            print(grid_header.body) 
+         
+        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE)) 
+        div_expr = div_any_type + SkipTo(div | div_end)("body") 
+        for div_header in div_expr.searchString(html): 
+            print(div_header.body) 
+    prints:: 
+        1 4 0 1 0 
+ 
+        1 4 0 1 0 
+        1,3 2,3 1,1 
+    """ 
+    classattr = "%s:class" % namespace if namespace else "class" 
+    return withAttribute(**{classattr : classname})         
+ 
+opAssoc = _Constants() 
+opAssoc.LEFT = object() 
+opAssoc.RIGHT = object() 
+ 
+def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ): 
+    """ 
+    Helper method for constructing grammars of expressions made up of 
+    operators working in a precedence hierarchy.  Operators may be unary or 
+    binary, left- or right-associative.  Parse actions can also be attached 
+    to operator expressions. The generated parser will also recognize the use  
+    of parentheses to override operator precedences (see example below). 
+     
+    Note: if you define a deep operator list, you may see performance issues 
+    when using infixNotation. See L{ParserElement.enablePackrat} for a 
+    mechanism to potentially improve your parser performance. 
+ 
+    Parameters: 
+     - baseExpr - expression representing the most basic element for the nested 
+     - opList - list of tuples, one for each operator precedence level in the 
+      expression grammar; each tuple is of the form 
+      (opExpr, numTerms, rightLeftAssoc, parseAction), where: 
+       - opExpr is the pyparsing expression for the operator; 
+          may also be a string, which will be converted to a Literal; 
+          if numTerms is 3, opExpr is a tuple of two expressions, for the 
+          two operators separating the 3 terms 
+       - numTerms is the number of terms for this operator (must 
+          be 1, 2, or 3) 
+       - rightLeftAssoc is the indicator whether the operator is 
+          right or left associative, using the pyparsing-defined 
+          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}. 
+       - parseAction is the parse action to be associated with 
+          expressions matching this operator expression (the 
+          parse action tuple member may be omitted); if the parse action 
+          is passed a tuple or list of functions, this is equivalent to 
+          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction}) 
+     - lpar - expression for matching left-parentheses (default=C{Suppress('(')}) 
+     - rpar - expression for matching right-parentheses (default=C{Suppress(')')}) 
+ 
+    Example:: 
+        # simple example of four-function arithmetic with ints and variable names 
+        integer = pyparsing_common.signed_integer 
+        varname = pyparsing_common.identifier  
+         
+        arith_expr = infixNotation(integer | varname, 
+            [ 
+            ('-', 1, opAssoc.RIGHT), 
+            (oneOf('* /'), 2, opAssoc.LEFT), 
+            (oneOf('+ -'), 2, opAssoc.LEFT), 
+            ]) 
+         
+        arith_expr.runTests(''' 
+            5+3*6 
+            (5+3)*6 
+            -2--11 
+            ''', fullDump=False) 
+    prints:: 
+        5+3*6 
+        [[5, '+', [3, '*', 6]]] 
+ 
+        (5+3)*6 
+        [[[5, '+', 3], '*', 6]] 
+ 
+        -2--11 
+        [[['-', 2], '-', ['-', 11]]] 
+    """ 
+    ret = Forward() 
+    lastExpr = baseExpr | ( lpar + ret + rpar ) 
+    for i,operDef in enumerate(opList): 
+        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4] 
+        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr 
+        if arity == 3: 
+            if opExpr is None or len(opExpr) != 2: 
+                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions") 
+            opExpr1, opExpr2 = opExpr 
+        thisExpr = Forward().setName(termName) 
+        if rightLeftAssoc == opAssoc.LEFT: 
+            if arity == 1: 
+                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) ) 
+            elif arity == 2: 
+                if opExpr is not None: 
+                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) ) 
+                else: 
+                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) ) 
+            elif arity == 3: 
+                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \ 
+                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr ) 
+            else: 
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)") 
+        elif rightLeftAssoc == opAssoc.RIGHT: 
+            if arity == 1: 
+                # try to avoid LR with this extra test 
+                if not isinstance(opExpr, Optional): 
+                    opExpr = Optional(opExpr) 
+                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr ) 
+            elif arity == 2: 
+                if opExpr is not None: 
+                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) ) 
+                else: 
+                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) ) 
+            elif arity == 3: 
+                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \ 
+                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr ) 
+            else: 
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)") 
+        else: 
+            raise ValueError("operator must indicate right or left associativity") 
+        if pa: 
+            if isinstance(pa, (tuple, list)): 
+                matchExpr.setParseAction(*pa) 
+            else: 
+                matchExpr.setParseAction(pa) 
+        thisExpr <<= ( matchExpr.setName(termName) | lastExpr ) 
+        lastExpr = thisExpr 
+    ret <<= lastExpr 
+    return ret 
+ 
+operatorPrecedence = infixNotation 
+"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release.""" 
+ 
+dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes") 
+sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes") 
+quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'| 
+                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes") 
+unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal") 
+ 
+def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()): 
+    """ 
+    Helper method for defining nested lists enclosed in opening and closing 
+    delimiters ("(" and ")" are the default). 
+ 
+    Parameters: 
+     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression 
+     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression 
+     - content - expression for items within the nested lists (default=C{None}) 
+     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString}) 
+ 
+    If an expression is not provided for the content argument, the nested 
+    expression will capture all whitespace-delimited content between delimiters 
+    as a list of separate values. 
+ 
+    Use the C{ignoreExpr} argument to define expressions that may contain 
+    opening or closing characters that should not be treated as opening 
+    or closing characters for nesting, such as quotedString or a comment 
+    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}. 
+    The default is L{quotedString}, but if no expressions are to be ignored, 
+    then pass C{None} for this argument. 
+ 
+    Example:: 
+        data_type = oneOf("void int short long char float double") 
+        decl_data_type = Combine(data_type + Optional(Word('*'))) 
+        ident = Word(alphas+'_', alphanums+'_') 
+        number = pyparsing_common.number 
+        arg = Group(decl_data_type + ident) 
+        LPAR,RPAR = map(Suppress, "()") 
+ 
+        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment)) 
+ 
+        c_function = (decl_data_type("type")  
+                      + ident("name") 
+                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR  
+                      + code_body("body")) 
+        c_function.ignore(cStyleComment) 
+         
+        source_code = ''' 
+            int is_odd(int x) {  
+                return (x%2);  
+            } 
+                 
+            int dec_to_hex(char hchar) {  
+                if (hchar >= '0' && hchar <= '9') {  
+                    return (ord(hchar)-ord('0'));  
+                } else {  
+                    return (10+ord(hchar)-ord('A')); 
+                }  
+            } 
+        ''' 
+        for func in c_function.searchString(source_code): 
+            print("%(name)s (%(type)s) args: %(args)s" % func) 
+ 
+    prints:: 
+        is_odd (int) args: [['int', 'x']] 
+        dec_to_hex (int) args: [['char', 'hchar']] 
+    """ 
+    if opener == closer: 
+        raise ValueError("opening and closing strings cannot be the same") 
+    if content is None: 
+        if isinstance(opener,basestring) and isinstance(closer,basestring): 
+            if len(opener) == 1 and len(closer)==1: 
+                if ignoreExpr is not None: 
+                    content = (Combine(OneOrMore(~ignoreExpr + 
+                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1)) 
+                                ).setParseAction(lambda t:t[0].strip())) 
+                else: 
+                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS 
+                                ).setParseAction(lambda t:t[0].strip())) 
+            else: 
+                if ignoreExpr is not None: 
+                    content = (Combine(OneOrMore(~ignoreExpr +  
+                                    ~Literal(opener) + ~Literal(closer) + 
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1)) 
+                                ).setParseAction(lambda t:t[0].strip())) 
+                else: 
+                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) + 
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1)) 
+                                ).setParseAction(lambda t:t[0].strip())) 
+        else: 
+            raise ValueError("opening and closing arguments must be strings if no content expression is given") 
+    ret = Forward() 
+    if ignoreExpr is not None: 
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) ) 
+    else: 
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) ) 
+    ret.setName('nested %s%s expression' % (opener,closer)) 
+    return ret 
+ 
+def indentedBlock(blockStatementExpr, indentStack, indent=True): 
+    """ 
+    Helper method for defining space-delimited indentation blocks, such as 
+    those used to define block statements in Python source code. 
+ 
+    Parameters: 
+     - blockStatementExpr - expression defining syntax of statement that 
+            is repeated within the indented block 
+     - indentStack - list created by caller to manage indentation stack 
+            (multiple statementWithIndentedBlock expressions within a single grammar 
+            should share a common indentStack) 
+     - indent - boolean indicating whether block must be indented beyond the 
+            the current level; set to False for block of left-most statements 
+            (default=C{True}) 
+ 
+    A valid block must contain at least one C{blockStatement}. 
+ 
+    Example:: 
+        data = ''' 
+        def A(z): 
+          A1 
+          B = 100 
+          G = A2 
+          A2 
+          A3 
+        B 
+        def BB(a,b,c): 
+          BB1 
+          def BBA(): 
+            bba1 
+            bba2 
+            bba3 
+        C 
+        D 
+        def spam(x,y): 
+             def eggs(z): 
+                 pass 
+        ''' 
+ 
+ 
+        indentStack = [1] 
+        stmt = Forward() 
+ 
+        identifier = Word(alphas, alphanums) 
+        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":") 
+        func_body = indentedBlock(stmt, indentStack) 
+        funcDef = Group( funcDecl + func_body ) 
+ 
+        rvalue = Forward() 
+        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")") 
+        rvalue << (funcCall | identifier | Word(nums)) 
+        assignment = Group(identifier + "=" + rvalue) 
+        stmt << ( funcDef | assignment | identifier ) 
+ 
+        module_body = OneOrMore(stmt) 
+ 
+        parseTree = module_body.parseString(data) 
+        parseTree.pprint() 
+    prints:: 
+        [['def', 
+          'A', 
+          ['(', 'z', ')'], 
+          ':', 
+          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]], 
+         'B', 
+         ['def', 
+          'BB', 
+          ['(', 'a', 'b', 'c', ')'], 
+          ':', 
+          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]], 
+         'C', 
+         'D', 
+         ['def', 
+          'spam', 
+          ['(', 'x', 'y', ')'], 
+          ':', 
+          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]]  
+    """ 
+    def checkPeerIndent(s,l,t): 
+        if l >= len(s): return 
+        curCol = col(l,s) 
+        if curCol != indentStack[-1]: 
+            if curCol > indentStack[-1]: 
+                raise ParseFatalException(s,l,"illegal nesting") 
+            raise ParseException(s,l,"not a peer entry") 
+ 
+    def checkSubIndent(s,l,t): 
+        curCol = col(l,s) 
+        if curCol > indentStack[-1]: 
+            indentStack.append( curCol ) 
+        else: 
+            raise ParseException(s,l,"not a subentry") 
+ 
+    def checkUnindent(s,l,t): 
+        if l >= len(s): return 
+        curCol = col(l,s) 
+        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]): 
+            raise ParseException(s,l,"not an unindent") 
+        indentStack.pop() 
+ 
+    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress()) 
+    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT') 
+    PEER   = Empty().setParseAction(checkPeerIndent).setName('') 
+    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT') 
+    if indent: 
+        smExpr = Group( Optional(NL) + 
+            #~ FollowedBy(blockStatementExpr) + 
+            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT) 
+    else: 
+        smExpr = Group( Optional(NL) + 
+            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) ) 
+    blockStatementExpr.ignore(_bslash + LineEnd()) 
+    return smExpr.setName('indented block') 
+ 
+alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]") 
+punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]") 
+ 
+anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag')) 
+_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\'')) 
+commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity") 
+def replaceHTMLEntity(t): 
+    """Helper parser action to replace common HTML entities with their special characters""" 
+    return _htmlEntityMap.get(t.entity) 
+ 
+# it's easy to get these comment structures wrong - they're very common, so may as well make them available 
+cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment") 
+"Comment of the form C{/* ... */}" 
+ 
+htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment") 
+"Comment of the form C{<!-- ... -->}" 
+ 
+restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line") 
+dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment") 
+"Comment of the form C{// ... (to end of line)}" 
+ 
+cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment") 
+"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}" 
+ 
+javaStyleComment = cppStyleComment 
+"Same as C{L{cppStyleComment}}" 
+ 
+pythonStyleComment = Regex(r"#.*").setName("Python style comment") 
+"Comment of the form C{# ... (to end of line)}" 
+ 
+_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') + 
+                                  Optional( Word(" \t") + 
+                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem") 
+commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList") 
+"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas. 
+   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}.""" 
+ 
+# some other useful expressions - using lower-case class name since we are really using this as a namespace 
+class pyparsing_common: 
+    """ 
+    Here are some common low-level expressions that may be useful in jump-starting parser development: 
+     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>}) 
+     - common L{programming identifiers<identifier>} 
+     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>}) 
+     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>} 
+     - L{UUID<uuid>} 
+     - L{comma-separated list<comma_separated_list>} 
+    Parse actions: 
+     - C{L{convertToInteger}} 
+     - C{L{convertToFloat}} 
+     - C{L{convertToDate}} 
+     - C{L{convertToDatetime}} 
+     - C{L{stripHTMLTags}} 
+     - C{L{upcaseTokens}} 
+     - C{L{downcaseTokens}} 
+ 
+    Example:: 
+        pyparsing_common.number.runTests(''' 
+            # any int or real number, returned as the appropriate type 
+            100 
+            -100 
+            +100 
+            3.14159 
+            6.02e23 
+            1e-12 
+            ''') 
+ 
+        pyparsing_common.fnumber.runTests(''' 
+            # any int or real number, returned as float 
+            100 
+            -100 
+            +100 
+            3.14159 
+            6.02e23 
+            1e-12 
+            ''') 
+ 
+        pyparsing_common.hex_integer.runTests(''' 
+            # hex numbers 
+            100 
+            FF 
+            ''') 
+ 
+        pyparsing_common.fraction.runTests(''' 
+            # fractions 
+            1/2 
+            -3/4 
+            ''') 
+ 
+        pyparsing_common.mixed_integer.runTests(''' 
+            # mixed fractions 
+            1 
+            1/2 
+            -3/4 
+            1-3/4 
+            ''') 
+ 
+        import uuid 
+        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID)) 
+        pyparsing_common.uuid.runTests(''' 
+            # uuid 
+            12345678-1234-5678-1234-567812345678 
+            ''') 
+    prints:: 
+        # any int or real number, returned as the appropriate type 
+        100 
+        [100] 
+ 
+        -100 
+        [-100] 
+ 
+        +100 
+        [100] 
+ 
+        3.14159 
+        [3.14159] 
+ 
+        6.02e23 
+        [6.02e+23] 
+ 
+        1e-12 
+        [1e-12] 
+ 
+        # any int or real number, returned as float 
+        100 
+        [100.0] 
+ 
+        -100 
+        [-100.0] 
+ 
+        +100 
+        [100.0] 
+ 
+        3.14159 
+        [3.14159] 
+ 
+        6.02e23 
+        [6.02e+23] 
+ 
+        1e-12 
+        [1e-12] 
+ 
+        # hex numbers 
+        100 
+        [256] 
+ 
+        FF 
+        [255] 
+ 
+        # fractions 
+        1/2 
+        [0.5] 
+ 
+        -3/4 
+        [-0.75] 
+ 
+        # mixed fractions 
+        1 
+        [1] 
+ 
+        1/2 
+        [0.5] 
+ 
+        -3/4 
+        [-0.75] 
+ 
+        1-3/4 
+        [1.75] 
+ 
+        # uuid 
+        12345678-1234-5678-1234-567812345678 
+        [UUID('12345678-1234-5678-1234-567812345678')] 
+    """ 
+ 
+    convertToInteger = tokenMap(int) 
+    """ 
+    Parse action for converting parsed integers to Python int 
+    """ 
+ 
+    convertToFloat = tokenMap(float) 
+    """ 
+    Parse action for converting parsed numbers to Python float 
+    """ 
+ 
+    integer = Word(nums).setName("integer").setParseAction(convertToInteger) 
+    """expression that parses an unsigned integer, returns an int""" 
+ 
+    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16)) 
+    """expression that parses a hexadecimal integer, returns an int""" 
+ 
+    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger) 
+    """expression that parses an integer with optional leading sign, returns an int""" 
+ 
+    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction") 
+    """fractional expression of an integer divided by an integer, returns a float""" 
+    fraction.addParseAction(lambda t: t[0]/t[-1]) 
+ 
+    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction") 
+    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float""" 
+    mixed_integer.addParseAction(sum) 
+ 
+    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat) 
+    """expression that parses a floating point number and returns a float""" 
+ 
+    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat) 
+    """expression that parses a floating point number with optional scientific notation and returns a float""" 
+ 
+    # streamlining this expression makes the docs nicer-looking 
+    number = (sci_real | real | signed_integer).streamline() 
+    """any numeric expression, returns the corresponding Python type""" 
+ 
+    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat) 
+    """any int or real number, returned as float""" 
+     
+    identifier = Word(alphas+'_', alphanums+'_').setName("identifier") 
+    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')""" 
+     
+    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address") 
+    "IPv4 address (C{0.0.0.0 - 255.255.255.255})" 
+ 
+    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer") 
+    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address") 
+    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address") 
+    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8) 
+    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address") 
+    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address") 
+    "IPv6 address (long, short, or mixed form)" 
+     
+    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address") 
+    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)" 
+ 
+    @staticmethod 
+    def convertToDate(fmt="%Y-%m-%d"): 
+        """ 
+        Helper to create a parse action for converting parsed date string to Python datetime.date 
+ 
+        Params - 
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"}) 
+ 
+        Example:: 
+            date_expr = pyparsing_common.iso8601_date.copy() 
+            date_expr.setParseAction(pyparsing_common.convertToDate()) 
+            print(date_expr.parseString("1999-12-31")) 
+        prints:: 
+            [datetime.date(1999, 12, 31)] 
+        """ 
+        def cvt_fn(s,l,t): 
+            try: 
+                return datetime.strptime(t[0], fmt).date() 
+            except ValueError as ve: 
+                raise ParseException(s, l, str(ve)) 
+        return cvt_fn 
+ 
+    @staticmethod 
+    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"): 
+        """ 
+        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime 
+ 
+        Params - 
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"}) 
+ 
+        Example:: 
+            dt_expr = pyparsing_common.iso8601_datetime.copy() 
+            dt_expr.setParseAction(pyparsing_common.convertToDatetime()) 
+            print(dt_expr.parseString("1999-12-31T23:59:59.999")) 
+        prints:: 
+            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)] 
+        """ 
+        def cvt_fn(s,l,t): 
+            try: 
+                return datetime.strptime(t[0], fmt) 
+            except ValueError as ve: 
+                raise ParseException(s, l, str(ve)) 
+        return cvt_fn 
+ 
+    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date") 
+    "ISO8601 date (C{yyyy-mm-dd})" 
+ 
+    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime") 
+    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}" 
+ 
+    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID") 
+    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})" 
+ 
+    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress() 
+    @staticmethod 
+    def stripHTMLTags(s, l, tokens): 
+        """ 
+        Parse action to remove HTML tags from web page HTML source 
+ 
+        Example:: 
+            # strip HTML links from normal text  
+            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>' 
+            td,td_end = makeHTMLTags("TD") 
+            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end 
+             
+            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page' 
+        """ 
+        return pyparsing_common._html_stripper.transformString(tokens[0]) 
+ 
+    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',')  
+                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem") 
+    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list") 
+    """Predefined expression of 1 or more printable words or quoted strings, separated by commas.""" 
+ 
+    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper())) 
+    """Parse action to convert tokens to upper case.""" 
+ 
+    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower())) 
+    """Parse action to convert tokens to lower case.""" 
+ 
+ 
+if __name__ == "__main__": 
+ 
+    selectToken    = CaselessLiteral("select") 
+    fromToken      = CaselessLiteral("from") 
+ 
+    ident          = Word(alphas, alphanums + "_$") 
+ 
+    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens) 
+    columnNameList = Group(delimitedList(columnName)).setName("columns") 
+    columnSpec     = ('*' | columnNameList) 
+ 
+    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens) 
+    tableNameList  = Group(delimitedList(tableName)).setName("tables") 
+     
+    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables") 
+ 
+    # demo runTests method, including embedded comments in test string 
+    simpleSQL.runTests(""" 
+        # '*' as column list and dotted table name 
+        select * from SYS.XYZZY 
+ 
+        # caseless match on "SELECT", and casts back to "select" 
+        SELECT * from XYZZY, ABC 
+ 
+        # list of column names, and mixed case SELECT keyword 
+        Select AA,BB,CC from Sys.dual 
+ 
+        # multiple tables 
+        Select A, B, C from Sys.dual, Table2 
+ 
+        # invalid SELECT keyword - should fail 
+        Xelect A, B, C from Sys.dual 
+ 
+        # incomplete command - should fail 
+        Select 
+ 
+        # invalid column name - should fail 
+        Select ^^^ frox Sys.dual 
+ 
+        """) 
+ 
+    pyparsing_common.number.runTests(""" 
+        100 
+        -100 
+        +100 
+        3.14159 
+        6.02e23 
+        1e-12 
+        """) 
+ 
+    # any int or real number, returned as float 
+    pyparsing_common.fnumber.runTests(""" 
+        100 
+        -100 
+        +100 
+        3.14159 
+        6.02e23 
+        1e-12 
+        """) 
+ 
+    pyparsing_common.hex_integer.runTests(""" 
+        100 
+        FF 
+        """) 
+ 
+    import uuid 
+    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID)) 
+    pyparsing_common.uuid.runTests(""" 
+        12345678-1234-5678-1234-567812345678 
+        """) 
diff --git a/contrib/python/setuptools/py2/pkg_resources/_vendor/six.py b/contrib/python/setuptools/py2/pkg_resources/_vendor/six.py
index 190c0239cd..2d8569e762 100644
--- a/contrib/python/setuptools/py2/pkg_resources/_vendor/six.py
+++ b/contrib/python/setuptools/py2/pkg_resources/_vendor/six.py
@@ -1,868 +1,868 @@
-"""Utilities for writing code that runs on Python 2 and 3"""
-
-# Copyright (c) 2010-2015 Benjamin Peterson
-#
-# 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 __future__ import absolute_import
-
-import functools
-import itertools
-import operator
-import sys
-import types
-
-__author__ = "Benjamin Peterson <benjamin@python.org>"
-__version__ = "1.10.0"
-
-
-# Useful for very coarse version differentiation.
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-PY34 = sys.version_info[0:2] >= (3, 4)
-
-if PY3:
-    string_types = str,
-    integer_types = int,
-    class_types = type,
-    text_type = str
-    binary_type = bytes
-
-    MAXSIZE = sys.maxsize
-else:
-    string_types = basestring,
-    integer_types = (int, long)
-    class_types = (type, types.ClassType)
-    text_type = unicode
-    binary_type = str
-
-    if sys.platform.startswith("java"):
-        # Jython always uses 32 bits.
-        MAXSIZE = int((1 << 31) - 1)
-    else:
-        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
-        class X(object):
-
-            def __len__(self):
-                return 1 << 31
-        try:
-            len(X())
-        except OverflowError:
-            # 32-bit
-            MAXSIZE = int((1 << 31) - 1)
-        else:
-            # 64-bit
-            MAXSIZE = int((1 << 63) - 1)
-        del X
-
-
-def _add_doc(func, doc):
-    """Add documentation to a function."""
-    func.__doc__ = doc
-
-
-def _import_module(name):
-    """Import module, returning the module after the last dot."""
-    __import__(name)
-    return sys.modules[name]
-
-
-class _LazyDescr(object):
-
-    def __init__(self, name):
-        self.name = name
-
-    def __get__(self, obj, tp):
-        result = self._resolve()
-        setattr(obj, self.name, result)  # Invokes __set__.
-        try:
-            # This is a bit ugly, but it avoids running this again by
-            # removing this descriptor.
-            delattr(obj.__class__, self.name)
-        except AttributeError:
-            pass
-        return result
-
-
-class MovedModule(_LazyDescr):
-
-    def __init__(self, name, old, new=None):
-        super(MovedModule, self).__init__(name)
-        if PY3:
-            if new is None:
-                new = name
-            self.mod = new
-        else:
-            self.mod = old
-
-    def _resolve(self):
-        return _import_module(self.mod)
-
-    def __getattr__(self, attr):
-        _module = self._resolve()
-        value = getattr(_module, attr)
-        setattr(self, attr, value)
-        return value
-
-
-class _LazyModule(types.ModuleType):
-
-    def __init__(self, name):
-        super(_LazyModule, self).__init__(name)
-        self.__doc__ = self.__class__.__doc__
-
-    def __dir__(self):
-        attrs = ["__doc__", "__name__"]
-        attrs += [attr.name for attr in self._moved_attributes]
-        return attrs
-
-    # Subclasses should override this
-    _moved_attributes = []
-
-
-class MovedAttribute(_LazyDescr):
-
-    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
-        super(MovedAttribute, self).__init__(name)
-        if PY3:
-            if new_mod is None:
-                new_mod = name
-            self.mod = new_mod
-            if new_attr is None:
-                if old_attr is None:
-                    new_attr = name
-                else:
-                    new_attr = old_attr
-            self.attr = new_attr
-        else:
-            self.mod = old_mod
-            if old_attr is None:
-                old_attr = name
-            self.attr = old_attr
-
-    def _resolve(self):
-        module = _import_module(self.mod)
-        return getattr(module, self.attr)
-
-
-class _SixMetaPathImporter(object):
-
-    """
-    A meta path importer to import six.moves and its submodules.
-
-    This class implements a PEP302 finder and loader. It should be compatible
-    with Python 2.5 and all existing versions of Python3
-    """
-
-    def __init__(self, six_module_name):
-        self.name = six_module_name
-        self.known_modules = {}
-
-    def _add_module(self, mod, *fullnames):
-        for fullname in fullnames:
-            self.known_modules[self.name + "." + fullname] = mod
-
-    def _get_module(self, fullname):
-        return self.known_modules[self.name + "." + fullname]
-
-    def find_module(self, fullname, path=None):
-        if fullname in self.known_modules:
-            return self
-        return None
-
-    def __get_module(self, fullname):
-        try:
-            return self.known_modules[fullname]
-        except KeyError:
-            raise ImportError("This loader does not know module " + fullname)
-
-    def load_module(self, fullname):
-        try:
-            # in case of a reload
-            return sys.modules[fullname]
-        except KeyError:
-            pass
-        mod = self.__get_module(fullname)
-        if isinstance(mod, MovedModule):
-            mod = mod._resolve()
-        else:
-            mod.__loader__ = self
-        sys.modules[fullname] = mod
-        return mod
-
-    def is_package(self, fullname):
-        """
-        Return true, if the named module is a package.
-
-        We need this method to get correct spec objects with
-        Python 3.4 (see PEP451)
-        """
-        return hasattr(self.__get_module(fullname), "__path__")
-
-    def get_code(self, fullname):
-        """Return None
-
-        Required, if is_package is implemented"""
-        self.__get_module(fullname)  # eventually raises ImportError
-        return None
-    get_source = get_code  # same as get_code
-
-_importer = _SixMetaPathImporter(__name__)
-
-
-class _MovedItems(_LazyModule):
-
-    """Lazy loading of moved objects"""
-    __path__ = []  # mark as package
-
-
-_moved_attributes = [
-    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
-    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
-    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
-    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
-    MovedAttribute("intern", "__builtin__", "sys"),
-    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
-    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
-    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
-    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
-    MovedAttribute("reduce", "__builtin__", "functools"),
-    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
-    MovedAttribute("StringIO", "StringIO", "io"),
-    MovedAttribute("UserDict", "UserDict", "collections"),
-    MovedAttribute("UserList", "UserList", "collections"),
-    MovedAttribute("UserString", "UserString", "collections"),
-    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
-    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
-    MovedModule("builtins", "__builtin__"),
-    MovedModule("configparser", "ConfigParser"),
-    MovedModule("copyreg", "copy_reg"),
-    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
-    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
-    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
-    MovedModule("http_cookies", "Cookie", "http.cookies"),
-    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
-    MovedModule("html_parser", "HTMLParser", "html.parser"),
-    MovedModule("http_client", "httplib", "http.client"),
-    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
-    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
-    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
-    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
-    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
-    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
-    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
-    MovedModule("cPickle", "cPickle", "pickle"),
-    MovedModule("queue", "Queue"),
-    MovedModule("reprlib", "repr"),
-    MovedModule("socketserver", "SocketServer"),
-    MovedModule("_thread", "thread", "_thread"),
-    MovedModule("tkinter", "Tkinter"),
-    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
-    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
-    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
-    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
-    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
-    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
-    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
-    MovedModule("tkinter_colorchooser", "tkColorChooser",
-                "tkinter.colorchooser"),
-    MovedModule("tkinter_commondialog", "tkCommonDialog",
-                "tkinter.commondialog"),
-    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
-    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
-    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
-                "tkinter.simpledialog"),
-    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
-    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
-    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
-    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
-    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
-    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
-]
-# Add windows specific modules.
-if sys.platform == "win32":
-    _moved_attributes += [
-        MovedModule("winreg", "_winreg"),
-    ]
-
-for attr in _moved_attributes:
-    setattr(_MovedItems, attr.name, attr)
-    if isinstance(attr, MovedModule):
-        _importer._add_module(attr, "moves." + attr.name)
-del attr
-
-_MovedItems._moved_attributes = _moved_attributes
-
-moves = _MovedItems(__name__ + ".moves")
-_importer._add_module(moves, "moves")
-
-
-class Module_six_moves_urllib_parse(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_parse"""
-
-
-_urllib_parse_moved_attributes = [
-    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
-    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
-    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
-    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
-    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("quote", "urllib", "urllib.parse"),
-    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("unquote", "urllib", "urllib.parse"),
-    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("urlencode", "urllib", "urllib.parse"),
-    MovedAttribute("splitquery", "urllib", "urllib.parse"),
-    MovedAttribute("splittag", "urllib", "urllib.parse"),
-    MovedAttribute("splituser", "urllib", "urllib.parse"),
-    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
-]
-for attr in _urllib_parse_moved_attributes:
-    setattr(Module_six_moves_urllib_parse, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
-                      "moves.urllib_parse", "moves.urllib.parse")
-
-
-class Module_six_moves_urllib_error(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_error"""
-
-
-_urllib_error_moved_attributes = [
-    MovedAttribute("URLError", "urllib2", "urllib.error"),
-    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
-    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
-]
-for attr in _urllib_error_moved_attributes:
-    setattr(Module_six_moves_urllib_error, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
-                      "moves.urllib_error", "moves.urllib.error")
-
-
-class Module_six_moves_urllib_request(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_request"""
-
-
-_urllib_request_moved_attributes = [
-    MovedAttribute("urlopen", "urllib2", "urllib.request"),
-    MovedAttribute("install_opener", "urllib2", "urllib.request"),
-    MovedAttribute("build_opener", "urllib2", "urllib.request"),
-    MovedAttribute("pathname2url", "urllib", "urllib.request"),
-    MovedAttribute("url2pathname", "urllib", "urllib.request"),
-    MovedAttribute("getproxies", "urllib", "urllib.request"),
-    MovedAttribute("Request", "urllib2", "urllib.request"),
-    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
-    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
-    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
-    MovedAttribute("URLopener", "urllib", "urllib.request"),
-    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
-    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
-]
-for attr in _urllib_request_moved_attributes:
-    setattr(Module_six_moves_urllib_request, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
-                      "moves.urllib_request", "moves.urllib.request")
-
-
-class Module_six_moves_urllib_response(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_response"""
-
-
-_urllib_response_moved_attributes = [
-    MovedAttribute("addbase", "urllib", "urllib.response"),
-    MovedAttribute("addclosehook", "urllib", "urllib.response"),
-    MovedAttribute("addinfo", "urllib", "urllib.response"),
-    MovedAttribute("addinfourl", "urllib", "urllib.response"),
-]
-for attr in _urllib_response_moved_attributes:
-    setattr(Module_six_moves_urllib_response, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
-                      "moves.urllib_response", "moves.urllib.response")
-
-
-class Module_six_moves_urllib_robotparser(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
-
-
-_urllib_robotparser_moved_attributes = [
-    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
-]
-for attr in _urllib_robotparser_moved_attributes:
-    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
-                      "moves.urllib_robotparser", "moves.urllib.robotparser")
-
-
-class Module_six_moves_urllib(types.ModuleType):
-
-    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
-    __path__ = []  # mark as package
-    parse = _importer._get_module("moves.urllib_parse")
-    error = _importer._get_module("moves.urllib_error")
-    request = _importer._get_module("moves.urllib_request")
-    response = _importer._get_module("moves.urllib_response")
-    robotparser = _importer._get_module("moves.urllib_robotparser")
-
-    def __dir__(self):
-        return ['parse', 'error', 'request', 'response', 'robotparser']
-
-_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
-                      "moves.urllib")
-
-
-def add_move(move):
-    """Add an item to six.moves."""
-    setattr(_MovedItems, move.name, move)
-
-
-def remove_move(name):
-    """Remove item from six.moves."""
-    try:
-        delattr(_MovedItems, name)
-    except AttributeError:
-        try:
-            del moves.__dict__[name]
-        except KeyError:
-            raise AttributeError("no such move, %r" % (name,))
-
-
-if PY3:
-    _meth_func = "__func__"
-    _meth_self = "__self__"
-
-    _func_closure = "__closure__"
-    _func_code = "__code__"
-    _func_defaults = "__defaults__"
-    _func_globals = "__globals__"
-else:
-    _meth_func = "im_func"
-    _meth_self = "im_self"
-
-    _func_closure = "func_closure"
-    _func_code = "func_code"
-    _func_defaults = "func_defaults"
-    _func_globals = "func_globals"
-
-
-try:
-    advance_iterator = next
-except NameError:
-    def advance_iterator(it):
-        return it.next()
-next = advance_iterator
-
-
-try:
-    callable = callable
-except NameError:
-    def callable(obj):
-        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
-
-
-if PY3:
-    def get_unbound_function(unbound):
-        return unbound
-
-    create_bound_method = types.MethodType
-
-    def create_unbound_method(func, cls):
-        return func
-
-    Iterator = object
-else:
-    def get_unbound_function(unbound):
-        return unbound.im_func
-
-    def create_bound_method(func, obj):
-        return types.MethodType(func, obj, obj.__class__)
-
-    def create_unbound_method(func, cls):
-        return types.MethodType(func, None, cls)
-
-    class Iterator(object):
-
-        def next(self):
-            return type(self).__next__(self)
-
-    callable = callable
-_add_doc(get_unbound_function,
-         """Get the function out of a possibly unbound function""")
-
-
-get_method_function = operator.attrgetter(_meth_func)
-get_method_self = operator.attrgetter(_meth_self)
-get_function_closure = operator.attrgetter(_func_closure)
-get_function_code = operator.attrgetter(_func_code)
-get_function_defaults = operator.attrgetter(_func_defaults)
-get_function_globals = operator.attrgetter(_func_globals)
-
-
-if PY3:
-    def iterkeys(d, **kw):
-        return iter(d.keys(**kw))
-
-    def itervalues(d, **kw):
-        return iter(d.values(**kw))
-
-    def iteritems(d, **kw):
-        return iter(d.items(**kw))
-
-    def iterlists(d, **kw):
-        return iter(d.lists(**kw))
-
-    viewkeys = operator.methodcaller("keys")
-
-    viewvalues = operator.methodcaller("values")
-
-    viewitems = operator.methodcaller("items")
-else:
-    def iterkeys(d, **kw):
-        return d.iterkeys(**kw)
-
-    def itervalues(d, **kw):
-        return d.itervalues(**kw)
-
-    def iteritems(d, **kw):
-        return d.iteritems(**kw)
-
-    def iterlists(d, **kw):
-        return d.iterlists(**kw)
-
-    viewkeys = operator.methodcaller("viewkeys")
-
-    viewvalues = operator.methodcaller("viewvalues")
-
-    viewitems = operator.methodcaller("viewitems")
-
-_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
-_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
-_add_doc(iteritems,
-         "Return an iterator over the (key, value) pairs of a dictionary.")
-_add_doc(iterlists,
-         "Return an iterator over the (key, [values]) pairs of a dictionary.")
-
-
-if PY3:
-    def b(s):
-        return s.encode("latin-1")
-
-    def u(s):
-        return s
-    unichr = chr
-    import struct
-    int2byte = struct.Struct(">B").pack
-    del struct
-    byte2int = operator.itemgetter(0)
-    indexbytes = operator.getitem
-    iterbytes = iter
-    import io
-    StringIO = io.StringIO
-    BytesIO = io.BytesIO
-    _assertCountEqual = "assertCountEqual"
-    if sys.version_info[1] <= 1:
-        _assertRaisesRegex = "assertRaisesRegexp"
-        _assertRegex = "assertRegexpMatches"
-    else:
-        _assertRaisesRegex = "assertRaisesRegex"
-        _assertRegex = "assertRegex"
-else:
-    def b(s):
-        return s
-    # Workaround for standalone backslash
-
-    def u(s):
-        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
-    unichr = unichr
-    int2byte = chr
-
-    def byte2int(bs):
-        return ord(bs[0])
-
-    def indexbytes(buf, i):
-        return ord(buf[i])
-    iterbytes = functools.partial(itertools.imap, ord)
-    import StringIO
-    StringIO = BytesIO = StringIO.StringIO
-    _assertCountEqual = "assertItemsEqual"
-    _assertRaisesRegex = "assertRaisesRegexp"
-    _assertRegex = "assertRegexpMatches"
-_add_doc(b, """Byte literal""")
-_add_doc(u, """Text literal""")
-
-
-def assertCountEqual(self, *args, **kwargs):
-    return getattr(self, _assertCountEqual)(*args, **kwargs)
-
-
-def assertRaisesRegex(self, *args, **kwargs):
-    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
-
-
-def assertRegex(self, *args, **kwargs):
-    return getattr(self, _assertRegex)(*args, **kwargs)
-
-
-if PY3:
-    exec_ = getattr(moves.builtins, "exec")
-
-    def reraise(tp, value, tb=None):
-        if value is None:
-            value = tp()
-        if value.__traceback__ is not tb:
-            raise value.with_traceback(tb)
-        raise value
-
-else:
-    def exec_(_code_, _globs_=None, _locs_=None):
-        """Execute code in a namespace."""
-        if _globs_ is None:
-            frame = sys._getframe(1)
-            _globs_ = frame.f_globals
-            if _locs_ is None:
-                _locs_ = frame.f_locals
-            del frame
-        elif _locs_ is None:
-            _locs_ = _globs_
-        exec("""exec _code_ in _globs_, _locs_""")
-
-    exec_("""def reraise(tp, value, tb=None):
-    raise tp, value, tb
-""")
-
-
-if sys.version_info[:2] == (3, 2):
-    exec_("""def raise_from(value, from_value):
-    if from_value is None:
-        raise value
-    raise value from from_value
-""")
-elif sys.version_info[:2] > (3, 2):
-    exec_("""def raise_from(value, from_value):
-    raise value from from_value
-""")
-else:
-    def raise_from(value, from_value):
-        raise value
-
-
-print_ = getattr(moves.builtins, "print", None)
-if print_ is None:
-    def print_(*args, **kwargs):
-        """The new-style print function for Python 2.4 and 2.5."""
-        fp = kwargs.pop("file", sys.stdout)
-        if fp is None:
-            return
-
-        def write(data):
-            if not isinstance(data, basestring):
-                data = str(data)
-            # If the file has an encoding, encode unicode with it.
-            if (isinstance(fp, file) and
-                    isinstance(data, unicode) and
-                    fp.encoding is not None):
-                errors = getattr(fp, "errors", None)
-                if errors is None:
-                    errors = "strict"
-                data = data.encode(fp.encoding, errors)
-            fp.write(data)
-        want_unicode = False
-        sep = kwargs.pop("sep", None)
-        if sep is not None:
-            if isinstance(sep, unicode):
-                want_unicode = True
-            elif not isinstance(sep, str):
-                raise TypeError("sep must be None or a string")
-        end = kwargs.pop("end", None)
-        if end is not None:
-            if isinstance(end, unicode):
-                want_unicode = True
-            elif not isinstance(end, str):
-                raise TypeError("end must be None or a string")
-        if kwargs:
-            raise TypeError("invalid keyword arguments to print()")
-        if not want_unicode:
-            for arg in args:
-                if isinstance(arg, unicode):
-                    want_unicode = True
-                    break
-        if want_unicode:
-            newline = unicode("\n")
-            space = unicode(" ")
-        else:
-            newline = "\n"
-            space = " "
-        if sep is None:
-            sep = space
-        if end is None:
-            end = newline
-        for i, arg in enumerate(args):
-            if i:
-                write(sep)
-            write(arg)
-        write(end)
-if sys.version_info[:2] < (3, 3):
-    _print = print_
-
-    def print_(*args, **kwargs):
-        fp = kwargs.get("file", sys.stdout)
-        flush = kwargs.pop("flush", False)
-        _print(*args, **kwargs)
-        if flush and fp is not None:
-            fp.flush()
-
-_add_doc(reraise, """Reraise an exception.""")
-
-if sys.version_info[0:2] < (3, 4):
-    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
-              updated=functools.WRAPPER_UPDATES):
-        def wrapper(f):
-            f = functools.wraps(wrapped, assigned, updated)(f)
-            f.__wrapped__ = wrapped
-            return f
-        return wrapper
-else:
-    wraps = functools.wraps
-
-
-def with_metaclass(meta, *bases):
-    """Create a base class with a metaclass."""
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
-    class metaclass(meta):
-
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
-
-
-def add_metaclass(metaclass):
-    """Class decorator for creating a class with a metaclass."""
-    def wrapper(cls):
-        orig_vars = cls.__dict__.copy()
-        slots = orig_vars.get('__slots__')
-        if slots is not None:
-            if isinstance(slots, str):
-                slots = [slots]
-            for slots_var in slots:
-                orig_vars.pop(slots_var)
-        orig_vars.pop('__dict__', None)
-        orig_vars.pop('__weakref__', None)
-        return metaclass(cls.__name__, cls.__bases__, orig_vars)
-    return wrapper
-
-
-def python_2_unicode_compatible(klass):
-    """
-    A decorator that defines __unicode__ and __str__ methods under Python 2.
-    Under Python 3 it does nothing.
-
-    To support Python 2 and 3 with a single code base, define a __str__ method
-    returning text and apply this decorator to the class.
-    """
-    if PY2:
-        if '__str__' not in klass.__dict__:
-            raise ValueError("@python_2_unicode_compatible cannot be applied "
-                             "to %s because it doesn't define __str__()." %
-                             klass.__name__)
-        klass.__unicode__ = klass.__str__
-        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
-    return klass
-
-
-# Complete the moves implementation.
-# This code is at the end of this module to speed up module loading.
-# Turn this module into a package.
-__path__ = []  # required for PEP 302 and PEP 451
-__package__ = __name__  # see PEP 366 @ReservedAssignment
-if globals().get("__spec__") is not None:
-    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
-# Remove other six meta path importers, since they cause problems. This can
-# happen if six is removed from sys.modules and then reloaded. (Setuptools does
-# this for some reason.)
-if sys.meta_path:
-    for i, importer in enumerate(sys.meta_path):
-        # Here's some real nastiness: Another "instance" of the six module might
-        # be floating around. Therefore, we can't use isinstance() to check for
-        # the six meta path importer, since the other six instance will have
-        # inserted an importer with different class.
-        if (type(importer).__name__ == "_SixMetaPathImporter" and
-                importer.name == __name__):
-            del sys.meta_path[i]
-            break
-    del i, importer
-# Finally, add the importer to the meta path import hook.
-sys.meta_path.append(_importer)
+"""Utilities for writing code that runs on Python 2 and 3""" 
+ 
+# Copyright (c) 2010-2015 Benjamin Peterson 
+# 
+# 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 __future__ import absolute_import 
+ 
+import functools 
+import itertools 
+import operator 
+import sys 
+import types 
+ 
+__author__ = "Benjamin Peterson <benjamin@python.org>" 
+__version__ = "1.10.0" 
+ 
+ 
+# Useful for very coarse version differentiation. 
+PY2 = sys.version_info[0] == 2 
+PY3 = sys.version_info[0] == 3 
+PY34 = sys.version_info[0:2] >= (3, 4) 
+ 
+if PY3: 
+    string_types = str, 
+    integer_types = int, 
+    class_types = type, 
+    text_type = str 
+    binary_type = bytes 
+ 
+    MAXSIZE = sys.maxsize 
+else: 
+    string_types = basestring, 
+    integer_types = (int, long) 
+    class_types = (type, types.ClassType) 
+    text_type = unicode 
+    binary_type = str 
+ 
+    if sys.platform.startswith("java"): 
+        # Jython always uses 32 bits. 
+        MAXSIZE = int((1 << 31) - 1) 
+    else: 
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t). 
+        class X(object): 
+ 
+            def __len__(self): 
+                return 1 << 31 
+        try: 
+            len(X()) 
+        except OverflowError: 
+            # 32-bit 
+            MAXSIZE = int((1 << 31) - 1) 
+        else: 
+            # 64-bit 
+            MAXSIZE = int((1 << 63) - 1) 
+        del X 
+ 
+ 
+def _add_doc(func, doc): 
+    """Add documentation to a function.""" 
+    func.__doc__ = doc 
+ 
+ 
+def _import_module(name): 
+    """Import module, returning the module after the last dot.""" 
+    __import__(name) 
+    return sys.modules[name] 
+ 
+ 
+class _LazyDescr(object): 
+ 
+    def __init__(self, name): 
+        self.name = name 
+ 
+    def __get__(self, obj, tp): 
+        result = self._resolve() 
+        setattr(obj, self.name, result)  # Invokes __set__. 
+        try: 
+            # This is a bit ugly, but it avoids running this again by 
+            # removing this descriptor. 
+            delattr(obj.__class__, self.name) 
+        except AttributeError: 
+            pass 
+        return result 
+ 
+ 
+class MovedModule(_LazyDescr): 
+ 
+    def __init__(self, name, old, new=None): 
+        super(MovedModule, self).__init__(name) 
+        if PY3: 
+            if new is None: 
+                new = name 
+            self.mod = new 
+        else: 
+            self.mod = old 
+ 
+    def _resolve(self): 
+        return _import_module(self.mod) 
+ 
+    def __getattr__(self, attr): 
+        _module = self._resolve() 
+        value = getattr(_module, attr) 
+        setattr(self, attr, value) 
+        return value 
+ 
+ 
+class _LazyModule(types.ModuleType): 
+ 
+    def __init__(self, name): 
+        super(_LazyModule, self).__init__(name) 
+        self.__doc__ = self.__class__.__doc__ 
+ 
+    def __dir__(self): 
+        attrs = ["__doc__", "__name__"] 
+        attrs += [attr.name for attr in self._moved_attributes] 
+        return attrs 
+ 
+    # Subclasses should override this 
+    _moved_attributes = [] 
+ 
+ 
+class MovedAttribute(_LazyDescr): 
+ 
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): 
+        super(MovedAttribute, self).__init__(name) 
+        if PY3: 
+            if new_mod is None: 
+                new_mod = name 
+            self.mod = new_mod 
+            if new_attr is None: 
+                if old_attr is None: 
+                    new_attr = name 
+                else: 
+                    new_attr = old_attr 
+            self.attr = new_attr 
+        else: 
+            self.mod = old_mod 
+            if old_attr is None: 
+                old_attr = name 
+            self.attr = old_attr 
+ 
+    def _resolve(self): 
+        module = _import_module(self.mod) 
+        return getattr(module, self.attr) 
+ 
+ 
+class _SixMetaPathImporter(object): 
+ 
+    """ 
+    A meta path importer to import six.moves and its submodules. 
+ 
+    This class implements a PEP302 finder and loader. It should be compatible 
+    with Python 2.5 and all existing versions of Python3 
+    """ 
+ 
+    def __init__(self, six_module_name): 
+        self.name = six_module_name 
+        self.known_modules = {} 
+ 
+    def _add_module(self, mod, *fullnames): 
+        for fullname in fullnames: 
+            self.known_modules[self.name + "." + fullname] = mod 
+ 
+    def _get_module(self, fullname): 
+        return self.known_modules[self.name + "." + fullname] 
+ 
+    def find_module(self, fullname, path=None): 
+        if fullname in self.known_modules: 
+            return self 
+        return None 
+ 
+    def __get_module(self, fullname): 
+        try: 
+            return self.known_modules[fullname] 
+        except KeyError: 
+            raise ImportError("This loader does not know module " + fullname) 
+ 
+    def load_module(self, fullname): 
+        try: 
+            # in case of a reload 
+            return sys.modules[fullname] 
+        except KeyError: 
+            pass 
+        mod = self.__get_module(fullname) 
+        if isinstance(mod, MovedModule): 
+            mod = mod._resolve() 
+        else: 
+            mod.__loader__ = self 
+        sys.modules[fullname] = mod 
+        return mod 
+ 
+    def is_package(self, fullname): 
+        """ 
+        Return true, if the named module is a package. 
+ 
+        We need this method to get correct spec objects with 
+        Python 3.4 (see PEP451) 
+        """ 
+        return hasattr(self.__get_module(fullname), "__path__") 
+ 
+    def get_code(self, fullname): 
+        """Return None 
+ 
+        Required, if is_package is implemented""" 
+        self.__get_module(fullname)  # eventually raises ImportError 
+        return None 
+    get_source = get_code  # same as get_code 
+ 
+_importer = _SixMetaPathImporter(__name__) 
+ 
+ 
+class _MovedItems(_LazyModule): 
+ 
+    """Lazy loading of moved objects""" 
+    __path__ = []  # mark as package 
+ 
+ 
+_moved_attributes = [ 
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), 
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), 
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), 
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), 
+    MovedAttribute("intern", "__builtin__", "sys"), 
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"), 
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), 
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), 
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), 
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"), 
+    MovedAttribute("reduce", "__builtin__", "functools"), 
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), 
+    MovedAttribute("StringIO", "StringIO", "io"), 
+    MovedAttribute("UserDict", "UserDict", "collections"), 
+    MovedAttribute("UserList", "UserList", "collections"), 
+    MovedAttribute("UserString", "UserString", "collections"), 
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), 
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), 
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), 
+    MovedModule("builtins", "__builtin__"), 
+    MovedModule("configparser", "ConfigParser"), 
+    MovedModule("copyreg", "copy_reg"), 
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), 
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"), 
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), 
+    MovedModule("http_cookies", "Cookie", "http.cookies"), 
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"), 
+    MovedModule("html_parser", "HTMLParser", "html.parser"), 
+    MovedModule("http_client", "httplib", "http.client"), 
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), 
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), 
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), 
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), 
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), 
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), 
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), 
+    MovedModule("cPickle", "cPickle", "pickle"), 
+    MovedModule("queue", "Queue"), 
+    MovedModule("reprlib", "repr"), 
+    MovedModule("socketserver", "SocketServer"), 
+    MovedModule("_thread", "thread", "_thread"), 
+    MovedModule("tkinter", "Tkinter"), 
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), 
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), 
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), 
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), 
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"), 
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), 
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), 
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), 
+    MovedModule("tkinter_colorchooser", "tkColorChooser", 
+                "tkinter.colorchooser"), 
+    MovedModule("tkinter_commondialog", "tkCommonDialog", 
+                "tkinter.commondialog"), 
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), 
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"), 
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), 
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", 
+                "tkinter.simpledialog"), 
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), 
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), 
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), 
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), 
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), 
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), 
+] 
+# Add windows specific modules. 
+if sys.platform == "win32": 
+    _moved_attributes += [ 
+        MovedModule("winreg", "_winreg"), 
+    ] 
+ 
+for attr in _moved_attributes: 
+    setattr(_MovedItems, attr.name, attr) 
+    if isinstance(attr, MovedModule): 
+        _importer._add_module(attr, "moves." + attr.name) 
+del attr 
+ 
+_MovedItems._moved_attributes = _moved_attributes 
+ 
+moves = _MovedItems(__name__ + ".moves") 
+_importer._add_module(moves, "moves") 
+ 
+ 
+class Module_six_moves_urllib_parse(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_parse""" 
+ 
+ 
+_urllib_parse_moved_attributes = [ 
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"), 
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"), 
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"), 
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), 
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"), 
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), 
+    MovedAttribute("quote", "urllib", "urllib.parse"), 
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"), 
+    MovedAttribute("unquote", "urllib", "urllib.parse"), 
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"), 
+    MovedAttribute("urlencode", "urllib", "urllib.parse"), 
+    MovedAttribute("splitquery", "urllib", "urllib.parse"), 
+    MovedAttribute("splittag", "urllib", "urllib.parse"), 
+    MovedAttribute("splituser", "urllib", "urllib.parse"), 
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"), 
+] 
+for attr in _urllib_parse_moved_attributes: 
+    setattr(Module_six_moves_urllib_parse, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), 
+                      "moves.urllib_parse", "moves.urllib.parse") 
+ 
+ 
+class Module_six_moves_urllib_error(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_error""" 
+ 
+ 
+_urllib_error_moved_attributes = [ 
+    MovedAttribute("URLError", "urllib2", "urllib.error"), 
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"), 
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), 
+] 
+for attr in _urllib_error_moved_attributes: 
+    setattr(Module_six_moves_urllib_error, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), 
+                      "moves.urllib_error", "moves.urllib.error") 
+ 
+ 
+class Module_six_moves_urllib_request(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_request""" 
+ 
+ 
+_urllib_request_moved_attributes = [ 
+    MovedAttribute("urlopen", "urllib2", "urllib.request"), 
+    MovedAttribute("install_opener", "urllib2", "urllib.request"), 
+    MovedAttribute("build_opener", "urllib2", "urllib.request"), 
+    MovedAttribute("pathname2url", "urllib", "urllib.request"), 
+    MovedAttribute("url2pathname", "urllib", "urllib.request"), 
+    MovedAttribute("getproxies", "urllib", "urllib.request"), 
+    MovedAttribute("Request", "urllib2", "urllib.request"), 
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), 
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), 
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), 
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"), 
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"), 
+    MovedAttribute("URLopener", "urllib", "urllib.request"), 
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"), 
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"), 
+] 
+for attr in _urllib_request_moved_attributes: 
+    setattr(Module_six_moves_urllib_request, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), 
+                      "moves.urllib_request", "moves.urllib.request") 
+ 
+ 
+class Module_six_moves_urllib_response(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_response""" 
+ 
+ 
+_urllib_response_moved_attributes = [ 
+    MovedAttribute("addbase", "urllib", "urllib.response"), 
+    MovedAttribute("addclosehook", "urllib", "urllib.response"), 
+    MovedAttribute("addinfo", "urllib", "urllib.response"), 
+    MovedAttribute("addinfourl", "urllib", "urllib.response"), 
+] 
+for attr in _urllib_response_moved_attributes: 
+    setattr(Module_six_moves_urllib_response, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), 
+                      "moves.urllib_response", "moves.urllib.response") 
+ 
+ 
+class Module_six_moves_urllib_robotparser(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_robotparser""" 
+ 
+ 
+_urllib_robotparser_moved_attributes = [ 
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), 
+] 
+for attr in _urllib_robotparser_moved_attributes: 
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), 
+                      "moves.urllib_robotparser", "moves.urllib.robotparser") 
+ 
+ 
+class Module_six_moves_urllib(types.ModuleType): 
+ 
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" 
+    __path__ = []  # mark as package 
+    parse = _importer._get_module("moves.urllib_parse") 
+    error = _importer._get_module("moves.urllib_error") 
+    request = _importer._get_module("moves.urllib_request") 
+    response = _importer._get_module("moves.urllib_response") 
+    robotparser = _importer._get_module("moves.urllib_robotparser") 
+ 
+    def __dir__(self): 
+        return ['parse', 'error', 'request', 'response', 'robotparser'] 
+ 
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), 
+                      "moves.urllib") 
+ 
+ 
+def add_move(move): 
+    """Add an item to six.moves.""" 
+    setattr(_MovedItems, move.name, move) 
+ 
+ 
+def remove_move(name): 
+    """Remove item from six.moves.""" 
+    try: 
+        delattr(_MovedItems, name) 
+    except AttributeError: 
+        try: 
+            del moves.__dict__[name] 
+        except KeyError: 
+            raise AttributeError("no such move, %r" % (name,)) 
+ 
+ 
+if PY3: 
+    _meth_func = "__func__" 
+    _meth_self = "__self__" 
+ 
+    _func_closure = "__closure__" 
+    _func_code = "__code__" 
+    _func_defaults = "__defaults__" 
+    _func_globals = "__globals__" 
+else: 
+    _meth_func = "im_func" 
+    _meth_self = "im_self" 
+ 
+    _func_closure = "func_closure" 
+    _func_code = "func_code" 
+    _func_defaults = "func_defaults" 
+    _func_globals = "func_globals" 
+ 
+ 
+try: 
+    advance_iterator = next 
+except NameError: 
+    def advance_iterator(it): 
+        return it.next() 
+next = advance_iterator 
+ 
+ 
+try: 
+    callable = callable 
+except NameError: 
+    def callable(obj): 
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) 
+ 
+ 
+if PY3: 
+    def get_unbound_function(unbound): 
+        return unbound 
+ 
+    create_bound_method = types.MethodType 
+ 
+    def create_unbound_method(func, cls): 
+        return func 
+ 
+    Iterator = object 
+else: 
+    def get_unbound_function(unbound): 
+        return unbound.im_func 
+ 
+    def create_bound_method(func, obj): 
+        return types.MethodType(func, obj, obj.__class__) 
+ 
+    def create_unbound_method(func, cls): 
+        return types.MethodType(func, None, cls) 
+ 
+    class Iterator(object): 
+ 
+        def next(self): 
+            return type(self).__next__(self) 
+ 
+    callable = callable 
+_add_doc(get_unbound_function, 
+         """Get the function out of a possibly unbound function""") 
+ 
+ 
+get_method_function = operator.attrgetter(_meth_func) 
+get_method_self = operator.attrgetter(_meth_self) 
+get_function_closure = operator.attrgetter(_func_closure) 
+get_function_code = operator.attrgetter(_func_code) 
+get_function_defaults = operator.attrgetter(_func_defaults) 
+get_function_globals = operator.attrgetter(_func_globals) 
+ 
+ 
+if PY3: 
+    def iterkeys(d, **kw): 
+        return iter(d.keys(**kw)) 
+ 
+    def itervalues(d, **kw): 
+        return iter(d.values(**kw)) 
+ 
+    def iteritems(d, **kw): 
+        return iter(d.items(**kw)) 
+ 
+    def iterlists(d, **kw): 
+        return iter(d.lists(**kw)) 
+ 
+    viewkeys = operator.methodcaller("keys") 
+ 
+    viewvalues = operator.methodcaller("values") 
+ 
+    viewitems = operator.methodcaller("items") 
+else: 
+    def iterkeys(d, **kw): 
+        return d.iterkeys(**kw) 
+ 
+    def itervalues(d, **kw): 
+        return d.itervalues(**kw) 
+ 
+    def iteritems(d, **kw): 
+        return d.iteritems(**kw) 
+ 
+    def iterlists(d, **kw): 
+        return d.iterlists(**kw) 
+ 
+    viewkeys = operator.methodcaller("viewkeys") 
+ 
+    viewvalues = operator.methodcaller("viewvalues") 
+ 
+    viewitems = operator.methodcaller("viewitems") 
+ 
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") 
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.") 
+_add_doc(iteritems, 
+         "Return an iterator over the (key, value) pairs of a dictionary.") 
+_add_doc(iterlists, 
+         "Return an iterator over the (key, [values]) pairs of a dictionary.") 
+ 
+ 
+if PY3: 
+    def b(s): 
+        return s.encode("latin-1") 
+ 
+    def u(s): 
+        return s 
+    unichr = chr 
+    import struct 
+    int2byte = struct.Struct(">B").pack 
+    del struct 
+    byte2int = operator.itemgetter(0) 
+    indexbytes = operator.getitem 
+    iterbytes = iter 
+    import io 
+    StringIO = io.StringIO 
+    BytesIO = io.BytesIO 
+    _assertCountEqual = "assertCountEqual" 
+    if sys.version_info[1] <= 1: 
+        _assertRaisesRegex = "assertRaisesRegexp" 
+        _assertRegex = "assertRegexpMatches" 
+    else: 
+        _assertRaisesRegex = "assertRaisesRegex" 
+        _assertRegex = "assertRegex" 
+else: 
+    def b(s): 
+        return s 
+    # Workaround for standalone backslash 
+ 
+    def u(s): 
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape") 
+    unichr = unichr 
+    int2byte = chr 
+ 
+    def byte2int(bs): 
+        return ord(bs[0]) 
+ 
+    def indexbytes(buf, i): 
+        return ord(buf[i]) 
+    iterbytes = functools.partial(itertools.imap, ord) 
+    import StringIO 
+    StringIO = BytesIO = StringIO.StringIO 
+    _assertCountEqual = "assertItemsEqual" 
+    _assertRaisesRegex = "assertRaisesRegexp" 
+    _assertRegex = "assertRegexpMatches" 
+_add_doc(b, """Byte literal""") 
+_add_doc(u, """Text literal""") 
+ 
+ 
+def assertCountEqual(self, *args, **kwargs): 
+    return getattr(self, _assertCountEqual)(*args, **kwargs) 
+ 
+ 
+def assertRaisesRegex(self, *args, **kwargs): 
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs) 
+ 
+ 
+def assertRegex(self, *args, **kwargs): 
+    return getattr(self, _assertRegex)(*args, **kwargs) 
+ 
+ 
+if PY3: 
+    exec_ = getattr(moves.builtins, "exec") 
+ 
+    def reraise(tp, value, tb=None): 
+        if value is None: 
+            value = tp() 
+        if value.__traceback__ is not tb: 
+            raise value.with_traceback(tb) 
+        raise value 
+ 
+else: 
+    def exec_(_code_, _globs_=None, _locs_=None): 
+        """Execute code in a namespace.""" 
+        if _globs_ is None: 
+            frame = sys._getframe(1) 
+            _globs_ = frame.f_globals 
+            if _locs_ is None: 
+                _locs_ = frame.f_locals 
+            del frame 
+        elif _locs_ is None: 
+            _locs_ = _globs_ 
+        exec("""exec _code_ in _globs_, _locs_""") 
+ 
+    exec_("""def reraise(tp, value, tb=None): 
+    raise tp, value, tb 
+""") 
+ 
+ 
+if sys.version_info[:2] == (3, 2): 
+    exec_("""def raise_from(value, from_value): 
+    if from_value is None: 
+        raise value 
+    raise value from from_value 
+""") 
+elif sys.version_info[:2] > (3, 2): 
+    exec_("""def raise_from(value, from_value): 
+    raise value from from_value 
+""") 
+else: 
+    def raise_from(value, from_value): 
+        raise value 
+ 
+ 
+print_ = getattr(moves.builtins, "print", None) 
+if print_ is None: 
+    def print_(*args, **kwargs): 
+        """The new-style print function for Python 2.4 and 2.5.""" 
+        fp = kwargs.pop("file", sys.stdout) 
+        if fp is None: 
+            return 
+ 
+        def write(data): 
+            if not isinstance(data, basestring): 
+                data = str(data) 
+            # If the file has an encoding, encode unicode with it. 
+            if (isinstance(fp, file) and 
+                    isinstance(data, unicode) and 
+                    fp.encoding is not None): 
+                errors = getattr(fp, "errors", None) 
+                if errors is None: 
+                    errors = "strict" 
+                data = data.encode(fp.encoding, errors) 
+            fp.write(data) 
+        want_unicode = False 
+        sep = kwargs.pop("sep", None) 
+        if sep is not None: 
+            if isinstance(sep, unicode): 
+                want_unicode = True 
+            elif not isinstance(sep, str): 
+                raise TypeError("sep must be None or a string") 
+        end = kwargs.pop("end", None) 
+        if end is not None: 
+            if isinstance(end, unicode): 
+                want_unicode = True 
+            elif not isinstance(end, str): 
+                raise TypeError("end must be None or a string") 
+        if kwargs: 
+            raise TypeError("invalid keyword arguments to print()") 
+        if not want_unicode: 
+            for arg in args: 
+                if isinstance(arg, unicode): 
+                    want_unicode = True 
+                    break 
+        if want_unicode: 
+            newline = unicode("\n") 
+            space = unicode(" ") 
+        else: 
+            newline = "\n" 
+            space = " " 
+        if sep is None: 
+            sep = space 
+        if end is None: 
+            end = newline 
+        for i, arg in enumerate(args): 
+            if i: 
+                write(sep) 
+            write(arg) 
+        write(end) 
+if sys.version_info[:2] < (3, 3): 
+    _print = print_ 
+ 
+    def print_(*args, **kwargs): 
+        fp = kwargs.get("file", sys.stdout) 
+        flush = kwargs.pop("flush", False) 
+        _print(*args, **kwargs) 
+        if flush and fp is not None: 
+            fp.flush() 
+ 
+_add_doc(reraise, """Reraise an exception.""") 
+ 
+if sys.version_info[0:2] < (3, 4): 
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, 
+              updated=functools.WRAPPER_UPDATES): 
+        def wrapper(f): 
+            f = functools.wraps(wrapped, assigned, updated)(f) 
+            f.__wrapped__ = wrapped 
+            return f 
+        return wrapper 
+else: 
+    wraps = functools.wraps 
+ 
+ 
+def with_metaclass(meta, *bases): 
+    """Create a base class with a metaclass.""" 
+    # This requires a bit of explanation: the basic idea is to make a dummy 
+    # metaclass for one level of class instantiation that replaces itself with 
+    # the actual metaclass. 
+    class metaclass(meta): 
+ 
+        def __new__(cls, name, this_bases, d): 
+            return meta(name, bases, d) 
+    return type.__new__(metaclass, 'temporary_class', (), {}) 
+ 
+ 
+def add_metaclass(metaclass): 
+    """Class decorator for creating a class with a metaclass.""" 
+    def wrapper(cls): 
+        orig_vars = cls.__dict__.copy() 
+        slots = orig_vars.get('__slots__') 
+        if slots is not None: 
+            if isinstance(slots, str): 
+                slots = [slots] 
+            for slots_var in slots: 
+                orig_vars.pop(slots_var) 
+        orig_vars.pop('__dict__', None) 
+        orig_vars.pop('__weakref__', None) 
+        return metaclass(cls.__name__, cls.__bases__, orig_vars) 
+    return wrapper 
+ 
+ 
+def python_2_unicode_compatible(klass): 
+    """ 
+    A decorator that defines __unicode__ and __str__ methods under Python 2. 
+    Under Python 3 it does nothing. 
+ 
+    To support Python 2 and 3 with a single code base, define a __str__ method 
+    returning text and apply this decorator to the class. 
+    """ 
+    if PY2: 
+        if '__str__' not in klass.__dict__: 
+            raise ValueError("@python_2_unicode_compatible cannot be applied " 
+                             "to %s because it doesn't define __str__()." % 
+                             klass.__name__) 
+        klass.__unicode__ = klass.__str__ 
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8') 
+    return klass 
+ 
+ 
+# Complete the moves implementation. 
+# This code is at the end of this module to speed up module loading. 
+# Turn this module into a package. 
+__path__ = []  # required for PEP 302 and PEP 451 
+__package__ = __name__  # see PEP 366 @ReservedAssignment 
+if globals().get("__spec__") is not None: 
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable 
+# Remove other six meta path importers, since they cause problems. This can 
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does 
+# this for some reason.) 
+if sys.meta_path: 
+    for i, importer in enumerate(sys.meta_path): 
+        # Here's some real nastiness: Another "instance" of the six module might 
+        # be floating around. Therefore, we can't use isinstance() to check for 
+        # the six meta path importer, since the other six instance will have 
+        # inserted an importer with different class. 
+        if (type(importer).__name__ == "_SixMetaPathImporter" and 
+                importer.name == __name__): 
+            del sys.meta_path[i] 
+            break 
+    del i, importer 
+# Finally, add the importer to the meta path import hook. 
+sys.meta_path.append(_importer) 
diff --git a/contrib/python/setuptools/py2/pkg_resources/extern/__init__.py b/contrib/python/setuptools/py2/pkg_resources/extern/__init__.py
index c1eb9e998f..9a10169a52 100644
--- a/contrib/python/setuptools/py2/pkg_resources/extern/__init__.py
+++ b/contrib/python/setuptools/py2/pkg_resources/extern/__init__.py
@@ -1,73 +1,73 @@
-import sys
-
-
-class VendorImporter:
-    """
-    A PEP 302 meta path importer for finding optionally-vendored
-    or otherwise naturally-installed packages from root_name.
-    """
-
-    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
-        self.root_name = root_name
-        self.vendored_names = set(vendored_names)
-        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
-
-    @property
-    def search_path(self):
-        """
-        Search first the vendor package then as a natural package.
-        """
-        yield self.vendor_pkg + '.'
-        yield ''
-
-    def find_module(self, fullname, path=None):
-        """
-        Return self when fullname starts with root_name and the
-        target module is one vendored through this importer.
-        """
-        root, base, target = fullname.partition(self.root_name + '.')
-        if root:
-            return
-        if not any(map(target.startswith, self.vendored_names)):
-            return
-        return self
-
-    def load_module(self, fullname):
-        """
-        Iterate over the search path to locate and load fullname.
-        """
-        root, base, target = fullname.partition(self.root_name + '.')
-        for prefix in self.search_path:
-            try:
-                extant = prefix + target
-                __import__(extant)
-                mod = sys.modules[extant]
-                sys.modules[fullname] = mod
-                # mysterious hack:
-                # Remove the reference to the extant package/module
-                # on later Python versions to cause relative imports
-                # in the vendor package to resolve the same modules
-                # as those going through this importer.
-                if prefix and sys.version_info > (3, 3):
-                    del sys.modules[extant]
-                return mod
-            except ImportError:
-                pass
-        else:
-            raise ImportError(
-                "The '{target}' package is required; "
-                "normally this is bundled with this package so if you get "
-                "this warning, consult the packager of your "
-                "distribution.".format(**locals())
-            )
-
-    def install(self):
-        """
-        Install this importer into sys.meta_path if not already present.
-        """
-        if self not in sys.meta_path:
-            sys.meta_path.append(self)
-
-
-names = 'packaging', 'pyparsing', 'six', 'appdirs'
-VendorImporter(__name__, names).install()
+import sys 
+ 
+ 
+class VendorImporter: 
+    """ 
+    A PEP 302 meta path importer for finding optionally-vendored 
+    or otherwise naturally-installed packages from root_name. 
+    """ 
+ 
+    def __init__(self, root_name, vendored_names=(), vendor_pkg=None): 
+        self.root_name = root_name 
+        self.vendored_names = set(vendored_names) 
+        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor') 
+ 
+    @property 
+    def search_path(self): 
+        """ 
+        Search first the vendor package then as a natural package. 
+        """ 
+        yield self.vendor_pkg + '.' 
+        yield '' 
+ 
+    def find_module(self, fullname, path=None): 
+        """ 
+        Return self when fullname starts with root_name and the 
+        target module is one vendored through this importer. 
+        """ 
+        root, base, target = fullname.partition(self.root_name + '.') 
+        if root: 
+            return 
+        if not any(map(target.startswith, self.vendored_names)): 
+            return 
+        return self 
+ 
+    def load_module(self, fullname): 
+        """ 
+        Iterate over the search path to locate and load fullname. 
+        """ 
+        root, base, target = fullname.partition(self.root_name + '.') 
+        for prefix in self.search_path: 
+            try: 
+                extant = prefix + target 
+                __import__(extant) 
+                mod = sys.modules[extant] 
+                sys.modules[fullname] = mod 
+                # mysterious hack: 
+                # Remove the reference to the extant package/module 
+                # on later Python versions to cause relative imports 
+                # in the vendor package to resolve the same modules 
+                # as those going through this importer. 
+                if prefix and sys.version_info > (3, 3): 
+                    del sys.modules[extant] 
+                return mod 
+            except ImportError: 
+                pass 
+        else: 
+            raise ImportError( 
+                "The '{target}' package is required; " 
+                "normally this is bundled with this package so if you get " 
+                "this warning, consult the packager of your " 
+                "distribution.".format(**locals()) 
+            ) 
+ 
+    def install(self): 
+        """ 
+        Install this importer into sys.meta_path if not already present. 
+        """ 
+        if self not in sys.meta_path: 
+            sys.meta_path.append(self) 
+ 
+ 
+names = 'packaging', 'pyparsing', 'six', 'appdirs' 
+VendorImporter(__name__, names).install() 
diff --git a/contrib/python/setuptools/py2/pkg_resources/py31compat.py b/contrib/python/setuptools/py2/pkg_resources/py31compat.py
index a381c424f9..6199c1542c 100644
--- a/contrib/python/setuptools/py2/pkg_resources/py31compat.py
+++ b/contrib/python/setuptools/py2/pkg_resources/py31compat.py
@@ -1,23 +1,23 @@
-import os
-import errno
-import sys
-
-from .extern import six
-
-
-def _makedirs_31(path, exist_ok=False):
-    try:
-        os.makedirs(path)
-    except OSError as exc:
-        if not exist_ok or exc.errno != errno.EEXIST:
-            raise
-
-
-# rely on compatibility behavior until mode considerations
-#  and exists_ok considerations are disentangled.
-# See https://github.com/pypa/setuptools/pull/1083#issuecomment-315168663
-needs_makedirs = (
-    six.PY2 or
-    (3, 4) <= sys.version_info < (3, 4, 1)
-)
-makedirs = _makedirs_31 if needs_makedirs else os.makedirs
+import os 
+import errno 
+import sys 
+ 
+from .extern import six 
+ 
+ 
+def _makedirs_31(path, exist_ok=False): 
+    try: 
+        os.makedirs(path) 
+    except OSError as exc: 
+        if not exist_ok or exc.errno != errno.EEXIST: 
+            raise 
+ 
+ 
+# rely on compatibility behavior until mode considerations 
+#  and exists_ok considerations are disentangled. 
+# See https://github.com/pypa/setuptools/pull/1083#issuecomment-315168663 
+needs_makedirs = ( 
+    six.PY2 or 
+    (3, 4) <= sys.version_info < (3, 4, 1) 
+) 
+makedirs = _makedirs_31 if needs_makedirs else os.makedirs 
diff --git a/contrib/python/setuptools/py2/setuptools/__init__.py b/contrib/python/setuptools/py2/setuptools/__init__.py
index 9d8ae1ed5f..fc347fb24c 100644
--- a/contrib/python/setuptools/py2/setuptools/__init__.py
+++ b/contrib/python/setuptools/py2/setuptools/__init__.py
@@ -1,38 +1,38 @@
 """Extensions to the 'distutils' for large or complex distributions"""
 
 import os
-import sys
+import sys 
 import functools
 import distutils.core
 import distutils.filelist
-import re
-from distutils.errors import DistutilsOptionError
+import re 
+from distutils.errors import DistutilsOptionError 
 from distutils.util import convert_path
 from fnmatch import fnmatchcase
 
-from ._deprecation_warning import SetuptoolsDeprecationWarning
-
-from setuptools.extern.six import PY3, string_types
-from setuptools.extern.six.moves import filter, map
+from ._deprecation_warning import SetuptoolsDeprecationWarning 
 
+from setuptools.extern.six import PY3, string_types 
+from setuptools.extern.six.moves import filter, map 
+ 
 import setuptools.version
 from setuptools.extension import Extension
 from setuptools.dist import Distribution, Feature
 from setuptools.depends import Require
 from . import monkey
 
-__metaclass__ = type
-
-
+__metaclass__ = type 
+ 
+ 
 __all__ = [
     'setup', 'Distribution', 'Feature', 'Command', 'Extension', 'Require',
-    'SetuptoolsDeprecationWarning',
-    'find_packages'
+    'SetuptoolsDeprecationWarning', 
+    'find_packages' 
 ]
 
-if PY3:
-  __all__.append('find_namespace_packages')
-
+if PY3: 
+  __all__.append('find_namespace_packages') 
+ 
 __version__ = setuptools.version.__version__
 
 bootstrap_install_from = None
@@ -44,7 +44,7 @@ run_2to3_on_doctests = True
 lib2to3_fixer_packages = ['lib2to3.fixes']
 
 
-class PackageFinder:
+class PackageFinder: 
     """
     Generate a list of all Python packages found within a directory
     """
@@ -122,48 +122,48 @@ class PEP420PackageFinder(PackageFinder):
 
 find_packages = PackageFinder.find
 
-if PY3:
-  find_namespace_packages = PEP420PackageFinder.find
-
-
-def _install_setup_requires(attrs):
-    # Note: do not use `setuptools.Distribution` directly, as
-    # our PEP 517 backend patch `distutils.core.Distribution`.
-    class MinimalDistribution(distutils.core.Distribution):
-        """
-        A minimal version of a distribution for supporting the
-        fetch_build_eggs interface.
-        """
-        def __init__(self, attrs):
-            _incl = 'dependency_links', 'setup_requires'
-            filtered = {
-                k: attrs[k]
-                for k in set(_incl) & set(attrs)
-            }
-            distutils.core.Distribution.__init__(self, filtered)
-
-        def finalize_options(self):
-            """
-            Disable finalize_options to avoid building the working set.
-            Ref #2158.
-            """
-
-    dist = MinimalDistribution(attrs)
-
-    # Honor setup.cfg's options.
-    dist.parse_config_files(ignore_option_errors=True)
-    if dist.setup_requires:
-        dist.fetch_build_eggs(dist.setup_requires)
-
-
-def setup(**attrs):
-    # Make sure we have any requirements needed to interpret 'attrs'.
-    _install_setup_requires(attrs)
-    return distutils.core.setup(**attrs)
-
-setup.__doc__ = distutils.core.setup.__doc__
-
-
+if PY3: 
+  find_namespace_packages = PEP420PackageFinder.find 
+
+ 
+def _install_setup_requires(attrs): 
+    # Note: do not use `setuptools.Distribution` directly, as 
+    # our PEP 517 backend patch `distutils.core.Distribution`. 
+    class MinimalDistribution(distutils.core.Distribution): 
+        """ 
+        A minimal version of a distribution for supporting the 
+        fetch_build_eggs interface. 
+        """ 
+        def __init__(self, attrs): 
+            _incl = 'dependency_links', 'setup_requires' 
+            filtered = { 
+                k: attrs[k] 
+                for k in set(_incl) & set(attrs) 
+            } 
+            distutils.core.Distribution.__init__(self, filtered) 
+ 
+        def finalize_options(self): 
+            """ 
+            Disable finalize_options to avoid building the working set. 
+            Ref #2158. 
+            """ 
+ 
+    dist = MinimalDistribution(attrs) 
+ 
+    # Honor setup.cfg's options. 
+    dist.parse_config_files(ignore_option_errors=True) 
+    if dist.setup_requires: 
+        dist.fetch_build_eggs(dist.setup_requires) 
+ 
+ 
+def setup(**attrs): 
+    # Make sure we have any requirements needed to interpret 'attrs'. 
+    _install_setup_requires(attrs) 
+    return distutils.core.setup(**attrs) 
+ 
+setup.__doc__ = distutils.core.setup.__doc__ 
+ 
+ 
 _Command = monkey.get_unpatched(distutils.core.Command)
 
 
@@ -180,37 +180,37 @@ class Command(_Command):
         _Command.__init__(self, dist)
         vars(self).update(kw)
 
-    def _ensure_stringlike(self, option, what, default=None):
-        val = getattr(self, option)
-        if val is None:
-            setattr(self, option, default)
-            return default
-        elif not isinstance(val, string_types):
-            raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
-                                       % (option, what, val))
-        return val
-
-    def ensure_string_list(self, option):
-        r"""Ensure that 'option' is a list of strings.  If 'option' is
-        currently a string, we split it either on /,\s*/ or /\s+/, so
-        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
-        ["foo", "bar", "baz"].
-        """
-        val = getattr(self, option)
-        if val is None:
-            return
-        elif isinstance(val, string_types):
-            setattr(self, option, re.split(r',\s*|\s+', val))
-        else:
-            if isinstance(val, list):
-                ok = all(isinstance(v, string_types) for v in val)
-            else:
-                ok = False
-            if not ok:
-                raise DistutilsOptionError(
-                      "'%s' must be a list of strings (got %r)"
-                      % (option, val))
-
+    def _ensure_stringlike(self, option, what, default=None): 
+        val = getattr(self, option) 
+        if val is None: 
+            setattr(self, option, default) 
+            return default 
+        elif not isinstance(val, string_types): 
+            raise DistutilsOptionError("'%s' must be a %s (got `%s`)" 
+                                       % (option, what, val)) 
+        return val 
+ 
+    def ensure_string_list(self, option): 
+        r"""Ensure that 'option' is a list of strings.  If 'option' is 
+        currently a string, we split it either on /,\s*/ or /\s+/, so 
+        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become 
+        ["foo", "bar", "baz"]. 
+        """ 
+        val = getattr(self, option) 
+        if val is None: 
+            return 
+        elif isinstance(val, string_types): 
+            setattr(self, option, re.split(r',\s*|\s+', val)) 
+        else: 
+            if isinstance(val, list): 
+                ok = all(isinstance(v, string_types) for v in val) 
+            else: 
+                ok = False 
+            if not ok: 
+                raise DistutilsOptionError( 
+                      "'%s' must be a list of strings (got %r)" 
+                      % (option, val)) 
+ 
     def reinitialize_command(self, command, reinit_subcommands=0, **kw):
         cmd = _Command.reinitialize_command(self, command, reinit_subcommands)
         vars(cmd).update(kw)
@@ -241,5 +241,5 @@ def findall(dir=os.curdir):
     return list(files)
 
 
-# Apply monkey patches
+# Apply monkey patches 
 monkey.patch_all()
diff --git a/contrib/python/setuptools/py2/setuptools/_deprecation_warning.py b/contrib/python/setuptools/py2/setuptools/_deprecation_warning.py
index 086b64dd38..105a4d42a9 100644
--- a/contrib/python/setuptools/py2/setuptools/_deprecation_warning.py
+++ b/contrib/python/setuptools/py2/setuptools/_deprecation_warning.py
@@ -1,7 +1,7 @@
-class SetuptoolsDeprecationWarning(Warning):
-    """
-    Base class for warning deprecations in ``setuptools``
-
-    This class is not derived from ``DeprecationWarning``, and as such is
-    visible by default.
-    """
+class SetuptoolsDeprecationWarning(Warning): 
+    """ 
+    Base class for warning deprecations in ``setuptools`` 
+ 
+    This class is not derived from ``DeprecationWarning``, and as such is 
+    visible by default. 
+    """ 
diff --git a/contrib/python/setuptools/py2/setuptools/_imp.py b/contrib/python/setuptools/py2/setuptools/_imp.py
index a3cce9b284..57b68f110c 100644
--- a/contrib/python/setuptools/py2/setuptools/_imp.py
+++ b/contrib/python/setuptools/py2/setuptools/_imp.py
@@ -1,73 +1,73 @@
-"""
-Re-implementation of find_module and get_frozen_object
-from the deprecated imp module.
-"""
-
-import os
-import importlib.util
-import importlib.machinery
-
-from .py34compat import module_from_spec
-
-
-PY_SOURCE = 1
-PY_COMPILED = 2
-C_EXTENSION = 3
-C_BUILTIN = 6
-PY_FROZEN = 7
-
-
-def find_module(module, paths=None):
-    """Just like 'imp.find_module()', but with package support"""
-    spec = importlib.util.find_spec(module, paths)
-    if spec is None:
-        raise ImportError("Can't find %s" % module)
-    if not spec.has_location and hasattr(spec, 'submodule_search_locations'):
-        spec = importlib.util.spec_from_loader('__init__.py', spec.loader)
-
-    kind = -1
-    file = None
-    static = isinstance(spec.loader, type)
-    if spec.origin == 'frozen' or static and issubclass(
-            spec.loader, importlib.machinery.FrozenImporter):
-        kind = PY_FROZEN
-        path = None  # imp compabilty
-        suffix = mode = ''  # imp compability
-    elif spec.origin == 'built-in' or static and issubclass(
-            spec.loader, importlib.machinery.BuiltinImporter):
-        kind = C_BUILTIN
-        path = None  # imp compabilty
-        suffix = mode = ''  # imp compability
-    elif spec.has_location:
-        path = spec.origin
-        suffix = os.path.splitext(path)[1]
-        mode = 'r' if suffix in importlib.machinery.SOURCE_SUFFIXES else 'rb'
-
-        if suffix in importlib.machinery.SOURCE_SUFFIXES:
-            kind = PY_SOURCE
-        elif suffix in importlib.machinery.BYTECODE_SUFFIXES:
-            kind = PY_COMPILED
-        elif suffix in importlib.machinery.EXTENSION_SUFFIXES:
-            kind = C_EXTENSION
-
-        if kind in {PY_SOURCE, PY_COMPILED}:
-            file = open(path, mode)
-    else:
-        path = None
-        suffix = mode = ''
-
-    return file, path, (suffix, mode, kind)
-
-
-def get_frozen_object(module, paths=None):
-    spec = importlib.util.find_spec(module, paths)
-    if not spec:
-        raise ImportError("Can't find %s" % module)
-    return spec.loader.get_code(module)
-
-
-def get_module(module, paths, info):
-    spec = importlib.util.find_spec(module, paths)
-    if not spec:
-        raise ImportError("Can't find %s" % module)
-    return module_from_spec(spec)
+""" 
+Re-implementation of find_module and get_frozen_object 
+from the deprecated imp module. 
+""" 
+ 
+import os 
+import importlib.util 
+import importlib.machinery 
+ 
+from .py34compat import module_from_spec 
+ 
+ 
+PY_SOURCE = 1 
+PY_COMPILED = 2 
+C_EXTENSION = 3 
+C_BUILTIN = 6 
+PY_FROZEN = 7 
+ 
+ 
+def find_module(module, paths=None): 
+    """Just like 'imp.find_module()', but with package support""" 
+    spec = importlib.util.find_spec(module, paths) 
+    if spec is None: 
+        raise ImportError("Can't find %s" % module) 
+    if not spec.has_location and hasattr(spec, 'submodule_search_locations'): 
+        spec = importlib.util.spec_from_loader('__init__.py', spec.loader) 
+ 
+    kind = -1 
+    file = None 
+    static = isinstance(spec.loader, type) 
+    if spec.origin == 'frozen' or static and issubclass( 
+            spec.loader, importlib.machinery.FrozenImporter): 
+        kind = PY_FROZEN 
+        path = None  # imp compabilty 
+        suffix = mode = ''  # imp compability 
+    elif spec.origin == 'built-in' or static and issubclass( 
+            spec.loader, importlib.machinery.BuiltinImporter): 
+        kind = C_BUILTIN 
+        path = None  # imp compabilty 
+        suffix = mode = ''  # imp compability 
+    elif spec.has_location: 
+        path = spec.origin 
+        suffix = os.path.splitext(path)[1] 
+        mode = 'r' if suffix in importlib.machinery.SOURCE_SUFFIXES else 'rb' 
+ 
+        if suffix in importlib.machinery.SOURCE_SUFFIXES: 
+            kind = PY_SOURCE 
+        elif suffix in importlib.machinery.BYTECODE_SUFFIXES: 
+            kind = PY_COMPILED 
+        elif suffix in importlib.machinery.EXTENSION_SUFFIXES: 
+            kind = C_EXTENSION 
+ 
+        if kind in {PY_SOURCE, PY_COMPILED}: 
+            file = open(path, mode) 
+    else: 
+        path = None 
+        suffix = mode = '' 
+ 
+    return file, path, (suffix, mode, kind) 
+ 
+ 
+def get_frozen_object(module, paths=None): 
+    spec = importlib.util.find_spec(module, paths) 
+    if not spec: 
+        raise ImportError("Can't find %s" % module) 
+    return spec.loader.get_code(module) 
+ 
+ 
+def get_module(module, paths, info): 
+    spec = importlib.util.find_spec(module, paths) 
+    if not spec: 
+        raise ImportError("Can't find %s" % module) 
+    return module_from_spec(spec) 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/ordered_set.py b/contrib/python/setuptools/py2/setuptools/_vendor/ordered_set.py
index 14876000de..f903e1d401 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/ordered_set.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/ordered_set.py
@@ -1,488 +1,488 @@
-"""
-An OrderedSet is a custom MutableSet that remembers its order, so that every
-entry has an index that can be looked up.
-
-Based on a recipe originally posted to ActiveState Recipes by Raymond Hettiger,
-and released under the MIT license.
-"""
-import itertools as it
-from collections import deque
-
-try:
-    # Python 3
-    from collections.abc import MutableSet, Sequence
-except ImportError:
-    # Python 2.7
-    from collections import MutableSet, Sequence
-
-SLICE_ALL = slice(None)
-__version__ = "3.1"
-
-
-def is_iterable(obj):
-    """
-    Are we being asked to look up a list of things, instead of a single thing?
-    We check for the `__iter__` attribute so that this can cover types that
-    don't have to be known by this module, such as NumPy arrays.
-
-    Strings, however, should be considered as atomic values to look up, not
-    iterables. The same goes for tuples, since they are immutable and therefore
-    valid entries.
-
-    We don't need to check for the Python 2 `unicode` type, because it doesn't
-    have an `__iter__` attribute anyway.
-    """
-    return (
-        hasattr(obj, "__iter__")
-        and not isinstance(obj, str)
-        and not isinstance(obj, tuple)
-    )
-
-
-class OrderedSet(MutableSet, Sequence):
-    """
-    An OrderedSet is a custom MutableSet that remembers its order, so that
-    every entry has an index that can be looked up.
-
-    Example:
-        >>> OrderedSet([1, 1, 2, 3, 2])
-        OrderedSet([1, 2, 3])
-    """
-
-    def __init__(self, iterable=None):
-        self.items = []
-        self.map = {}
-        if iterable is not None:
-            self |= iterable
-
-    def __len__(self):
-        """
-        Returns the number of unique elements in the ordered set
-
-        Example:
-            >>> len(OrderedSet([]))
-            0
-            >>> len(OrderedSet([1, 2]))
-            2
-        """
-        return len(self.items)
-
-    def __getitem__(self, index):
-        """
-        Get the item at a given index.
-
-        If `index` is a slice, you will get back that slice of items, as a
-        new OrderedSet.
-
-        If `index` is a list or a similar iterable, you'll get a list of
-        items corresponding to those indices. This is similar to NumPy's
-        "fancy indexing". The result is not an OrderedSet because you may ask
-        for duplicate indices, and the number of elements returned should be
-        the number of elements asked for.
-
-        Example:
-            >>> oset = OrderedSet([1, 2, 3])
-            >>> oset[1]
-            2
-        """
-        if isinstance(index, slice) and index == SLICE_ALL:
-            return self.copy()
-        elif is_iterable(index):
-            return [self.items[i] for i in index]
-        elif hasattr(index, "__index__") or isinstance(index, slice):
-            result = self.items[index]
-            if isinstance(result, list):
-                return self.__class__(result)
-            else:
-                return result
-        else:
-            raise TypeError("Don't know how to index an OrderedSet by %r" % index)
-
-    def copy(self):
-        """
-        Return a shallow copy of this object.
-
-        Example:
-            >>> this = OrderedSet([1, 2, 3])
-            >>> other = this.copy()
-            >>> this == other
-            True
-            >>> this is other
-            False
-        """
-        return self.__class__(self)
-
-    def __getstate__(self):
-        if len(self) == 0:
-            # The state can't be an empty list.
-            # We need to return a truthy value, or else __setstate__ won't be run.
-            #
-            # This could have been done more gracefully by always putting the state
-            # in a tuple, but this way is backwards- and forwards- compatible with
-            # previous versions of OrderedSet.
-            return (None,)
-        else:
-            return list(self)
-
-    def __setstate__(self, state):
-        if state == (None,):
-            self.__init__([])
-        else:
-            self.__init__(state)
-
-    def __contains__(self, key):
-        """
-        Test if the item is in this ordered set
-
-        Example:
-            >>> 1 in OrderedSet([1, 3, 2])
-            True
-            >>> 5 in OrderedSet([1, 3, 2])
-            False
-        """
-        return key in self.map
-
-    def add(self, key):
-        """
-        Add `key` as an item to this OrderedSet, then return its index.
-
-        If `key` is already in the OrderedSet, return the index it already
-        had.
-
-        Example:
-            >>> oset = OrderedSet()
-            >>> oset.append(3)
-            0
-            >>> print(oset)
-            OrderedSet([3])
-        """
-        if key not in self.map:
-            self.map[key] = len(self.items)
-            self.items.append(key)
-        return self.map[key]
-
-    append = add
-
-    def update(self, sequence):
-        """
-        Update the set with the given iterable sequence, then return the index
-        of the last element inserted.
-
-        Example:
-            >>> oset = OrderedSet([1, 2, 3])
-            >>> oset.update([3, 1, 5, 1, 4])
-            4
-            >>> print(oset)
-            OrderedSet([1, 2, 3, 5, 4])
-        """
-        item_index = None
-        try:
-            for item in sequence:
-                item_index = self.add(item)
-        except TypeError:
-            raise ValueError(
-                "Argument needs to be an iterable, got %s" % type(sequence)
-            )
-        return item_index
-
-    def index(self, key):
-        """
-        Get the index of a given entry, raising an IndexError if it's not
-        present.
-
-        `key` can be an iterable of entries that is not a string, in which case
-        this returns a list of indices.
-
-        Example:
-            >>> oset = OrderedSet([1, 2, 3])
-            >>> oset.index(2)
-            1
-        """
-        if is_iterable(key):
-            return [self.index(subkey) for subkey in key]
-        return self.map[key]
-
-    # Provide some compatibility with pd.Index
-    get_loc = index
-    get_indexer = index
-
-    def pop(self):
-        """
-        Remove and return the last element from the set.
-
-        Raises KeyError if the set is empty.
-
-        Example:
-            >>> oset = OrderedSet([1, 2, 3])
-            >>> oset.pop()
-            3
-        """
-        if not self.items:
-            raise KeyError("Set is empty")
-
-        elem = self.items[-1]
-        del self.items[-1]
-        del self.map[elem]
-        return elem
-
-    def discard(self, key):
-        """
-        Remove an element.  Do not raise an exception if absent.
-
-        The MutableSet mixin uses this to implement the .remove() method, which
-        *does* raise an error when asked to remove a non-existent item.
-
-        Example:
-            >>> oset = OrderedSet([1, 2, 3])
-            >>> oset.discard(2)
-            >>> print(oset)
-            OrderedSet([1, 3])
-            >>> oset.discard(2)
-            >>> print(oset)
-            OrderedSet([1, 3])
-        """
-        if key in self:
-            i = self.map[key]
-            del self.items[i]
-            del self.map[key]
-            for k, v in self.map.items():
-                if v >= i:
-                    self.map[k] = v - 1
-
-    def clear(self):
-        """
-        Remove all items from this OrderedSet.
-        """
-        del self.items[:]
-        self.map.clear()
-
-    def __iter__(self):
-        """
-        Example:
-            >>> list(iter(OrderedSet([1, 2, 3])))
-            [1, 2, 3]
-        """
-        return iter(self.items)
-
-    def __reversed__(self):
-        """
-        Example:
-            >>> list(reversed(OrderedSet([1, 2, 3])))
-            [3, 2, 1]
-        """
-        return reversed(self.items)
-
-    def __repr__(self):
-        if not self:
-            return "%s()" % (self.__class__.__name__,)
-        return "%s(%r)" % (self.__class__.__name__, list(self))
-
-    def __eq__(self, other):
-        """
-        Returns true if the containers have the same items. If `other` is a
-        Sequence, then order is checked, otherwise it is ignored.
-
-        Example:
-            >>> oset = OrderedSet([1, 3, 2])
-            >>> oset == [1, 3, 2]
-            True
-            >>> oset == [1, 2, 3]
-            False
-            >>> oset == [2, 3]
-            False
-            >>> oset == OrderedSet([3, 2, 1])
-            False
-        """
-        # In Python 2 deque is not a Sequence, so treat it as one for
-        # consistent behavior with Python 3.
-        if isinstance(other, (Sequence, deque)):
-            # Check that this OrderedSet contains the same elements, in the
-            # same order, as the other object.
-            return list(self) == list(other)
-        try:
-            other_as_set = set(other)
-        except TypeError:
-            # If `other` can't be converted into a set, it's not equal.
-            return False
-        else:
-            return set(self) == other_as_set
-
-    def union(self, *sets):
-        """
-        Combines all unique items.
-        Each items order is defined by its first appearance.
-
-        Example:
-            >>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0])
-            >>> print(oset)
-            OrderedSet([3, 1, 4, 5, 2, 0])
-            >>> oset.union([8, 9])
-            OrderedSet([3, 1, 4, 5, 2, 0, 8, 9])
-            >>> oset | {10}
-            OrderedSet([3, 1, 4, 5, 2, 0, 10])
-        """
-        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
-        containers = map(list, it.chain([self], sets))
-        items = it.chain.from_iterable(containers)
-        return cls(items)
-
-    def __and__(self, other):
-        # the parent implementation of this is backwards
-        return self.intersection(other)
-
-    def intersection(self, *sets):
-        """
-        Returns elements in common between all sets. Order is defined only
-        by the first set.
-
-        Example:
-            >>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3])
-            >>> print(oset)
-            OrderedSet([1, 2, 3])
-            >>> oset.intersection([2, 4, 5], [1, 2, 3, 4])
-            OrderedSet([2])
-            >>> oset.intersection()
-            OrderedSet([1, 2, 3])
-        """
-        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
-        if sets:
-            common = set.intersection(*map(set, sets))
-            items = (item for item in self if item in common)
-        else:
-            items = self
-        return cls(items)
-
-    def difference(self, *sets):
-        """
-        Returns all elements that are in this set but not the others.
-
-        Example:
-            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]))
-            OrderedSet([1, 3])
-            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3]))
-            OrderedSet([1])
-            >>> OrderedSet([1, 2, 3]) - OrderedSet([2])
-            OrderedSet([1, 3])
-            >>> OrderedSet([1, 2, 3]).difference()
-            OrderedSet([1, 2, 3])
-        """
-        cls = self.__class__
-        if sets:
-            other = set.union(*map(set, sets))
-            items = (item for item in self if item not in other)
-        else:
-            items = self
-        return cls(items)
-
-    def issubset(self, other):
-        """
-        Report whether another set contains this set.
-
-        Example:
-            >>> OrderedSet([1, 2, 3]).issubset({1, 2})
-            False
-            >>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4})
-            True
-            >>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5})
-            False
-        """
-        if len(self) > len(other):  # Fast check for obvious cases
-            return False
-        return all(item in other for item in self)
-
-    def issuperset(self, other):
-        """
-        Report whether this set contains another set.
-
-        Example:
-            >>> OrderedSet([1, 2]).issuperset([1, 2, 3])
-            False
-            >>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3})
-            True
-            >>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3})
-            False
-        """
-        if len(self) < len(other):  # Fast check for obvious cases
-            return False
-        return all(item in self for item in other)
-
-    def symmetric_difference(self, other):
-        """
-        Return the symmetric difference of two OrderedSets as a new set.
-        That is, the new set will contain all elements that are in exactly
-        one of the sets.
-
-        Their order will be preserved, with elements from `self` preceding
-        elements from `other`.
-
-        Example:
-            >>> this = OrderedSet([1, 4, 3, 5, 7])
-            >>> other = OrderedSet([9, 7, 1, 3, 2])
-            >>> this.symmetric_difference(other)
-            OrderedSet([4, 5, 9, 2])
-        """
-        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
-        diff1 = cls(self).difference(other)
-        diff2 = cls(other).difference(self)
-        return diff1.union(diff2)
-
-    def _update_items(self, items):
-        """
-        Replace the 'items' list of this OrderedSet with a new one, updating
-        self.map accordingly.
-        """
-        self.items = items
-        self.map = {item: idx for (idx, item) in enumerate(items)}
-
-    def difference_update(self, *sets):
-        """
-        Update this OrderedSet to remove items from one or more other sets.
-
-        Example:
-            >>> this = OrderedSet([1, 2, 3])
-            >>> this.difference_update(OrderedSet([2, 4]))
-            >>> print(this)
-            OrderedSet([1, 3])
-
-            >>> this = OrderedSet([1, 2, 3, 4, 5])
-            >>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6]))
-            >>> print(this)
-            OrderedSet([3, 5])
-        """
-        items_to_remove = set()
-        for other in sets:
-            items_to_remove |= set(other)
-        self._update_items([item for item in self.items if item not in items_to_remove])
-
-    def intersection_update(self, other):
-        """
-        Update this OrderedSet to keep only items in another set, preserving
-        their order in this set.
-
-        Example:
-            >>> this = OrderedSet([1, 4, 3, 5, 7])
-            >>> other = OrderedSet([9, 7, 1, 3, 2])
-            >>> this.intersection_update(other)
-            >>> print(this)
-            OrderedSet([1, 3, 7])
-        """
-        other = set(other)
-        self._update_items([item for item in self.items if item in other])
-
-    def symmetric_difference_update(self, other):
-        """
-        Update this OrderedSet to remove items from another set, then
-        add items from the other set that were not present in this set.
-
-        Example:
-            >>> this = OrderedSet([1, 4, 3, 5, 7])
-            >>> other = OrderedSet([9, 7, 1, 3, 2])
-            >>> this.symmetric_difference_update(other)
-            >>> print(this)
-            OrderedSet([4, 5, 9, 2])
-        """
-        items_to_add = [item for item in other if item not in self]
-        items_to_remove = set(other)
-        self._update_items(
-            [item for item in self.items if item not in items_to_remove] + items_to_add
-        )
+""" 
+An OrderedSet is a custom MutableSet that remembers its order, so that every 
+entry has an index that can be looked up. 
+ 
+Based on a recipe originally posted to ActiveState Recipes by Raymond Hettiger, 
+and released under the MIT license. 
+""" 
+import itertools as it 
+from collections import deque 
+ 
+try: 
+    # Python 3 
+    from collections.abc import MutableSet, Sequence 
+except ImportError: 
+    # Python 2.7 
+    from collections import MutableSet, Sequence 
+ 
+SLICE_ALL = slice(None) 
+__version__ = "3.1" 
+ 
+ 
+def is_iterable(obj): 
+    """ 
+    Are we being asked to look up a list of things, instead of a single thing? 
+    We check for the `__iter__` attribute so that this can cover types that 
+    don't have to be known by this module, such as NumPy arrays. 
+ 
+    Strings, however, should be considered as atomic values to look up, not 
+    iterables. The same goes for tuples, since they are immutable and therefore 
+    valid entries. 
+ 
+    We don't need to check for the Python 2 `unicode` type, because it doesn't 
+    have an `__iter__` attribute anyway. 
+    """ 
+    return ( 
+        hasattr(obj, "__iter__") 
+        and not isinstance(obj, str) 
+        and not isinstance(obj, tuple) 
+    ) 
+ 
+ 
+class OrderedSet(MutableSet, Sequence): 
+    """ 
+    An OrderedSet is a custom MutableSet that remembers its order, so that 
+    every entry has an index that can be looked up. 
+ 
+    Example: 
+        >>> OrderedSet([1, 1, 2, 3, 2]) 
+        OrderedSet([1, 2, 3]) 
+    """ 
+ 
+    def __init__(self, iterable=None): 
+        self.items = [] 
+        self.map = {} 
+        if iterable is not None: 
+            self |= iterable 
+ 
+    def __len__(self): 
+        """ 
+        Returns the number of unique elements in the ordered set 
+ 
+        Example: 
+            >>> len(OrderedSet([])) 
+            0 
+            >>> len(OrderedSet([1, 2])) 
+            2 
+        """ 
+        return len(self.items) 
+ 
+    def __getitem__(self, index): 
+        """ 
+        Get the item at a given index. 
+ 
+        If `index` is a slice, you will get back that slice of items, as a 
+        new OrderedSet. 
+ 
+        If `index` is a list or a similar iterable, you'll get a list of 
+        items corresponding to those indices. This is similar to NumPy's 
+        "fancy indexing". The result is not an OrderedSet because you may ask 
+        for duplicate indices, and the number of elements returned should be 
+        the number of elements asked for. 
+ 
+        Example: 
+            >>> oset = OrderedSet([1, 2, 3]) 
+            >>> oset[1] 
+            2 
+        """ 
+        if isinstance(index, slice) and index == SLICE_ALL: 
+            return self.copy() 
+        elif is_iterable(index): 
+            return [self.items[i] for i in index] 
+        elif hasattr(index, "__index__") or isinstance(index, slice): 
+            result = self.items[index] 
+            if isinstance(result, list): 
+                return self.__class__(result) 
+            else: 
+                return result 
+        else: 
+            raise TypeError("Don't know how to index an OrderedSet by %r" % index) 
+ 
+    def copy(self): 
+        """ 
+        Return a shallow copy of this object. 
+ 
+        Example: 
+            >>> this = OrderedSet([1, 2, 3]) 
+            >>> other = this.copy() 
+            >>> this == other 
+            True 
+            >>> this is other 
+            False 
+        """ 
+        return self.__class__(self) 
+ 
+    def __getstate__(self): 
+        if len(self) == 0: 
+            # The state can't be an empty list. 
+            # We need to return a truthy value, or else __setstate__ won't be run. 
+            # 
+            # This could have been done more gracefully by always putting the state 
+            # in a tuple, but this way is backwards- and forwards- compatible with 
+            # previous versions of OrderedSet. 
+            return (None,) 
+        else: 
+            return list(self) 
+ 
+    def __setstate__(self, state): 
+        if state == (None,): 
+            self.__init__([]) 
+        else: 
+            self.__init__(state) 
+ 
+    def __contains__(self, key): 
+        """ 
+        Test if the item is in this ordered set 
+ 
+        Example: 
+            >>> 1 in OrderedSet([1, 3, 2]) 
+            True 
+            >>> 5 in OrderedSet([1, 3, 2]) 
+            False 
+        """ 
+        return key in self.map 
+ 
+    def add(self, key): 
+        """ 
+        Add `key` as an item to this OrderedSet, then return its index. 
+ 
+        If `key` is already in the OrderedSet, return the index it already 
+        had. 
+ 
+        Example: 
+            >>> oset = OrderedSet() 
+            >>> oset.append(3) 
+            0 
+            >>> print(oset) 
+            OrderedSet([3]) 
+        """ 
+        if key not in self.map: 
+            self.map[key] = len(self.items) 
+            self.items.append(key) 
+        return self.map[key] 
+ 
+    append = add 
+ 
+    def update(self, sequence): 
+        """ 
+        Update the set with the given iterable sequence, then return the index 
+        of the last element inserted. 
+ 
+        Example: 
+            >>> oset = OrderedSet([1, 2, 3]) 
+            >>> oset.update([3, 1, 5, 1, 4]) 
+            4 
+            >>> print(oset) 
+            OrderedSet([1, 2, 3, 5, 4]) 
+        """ 
+        item_index = None 
+        try: 
+            for item in sequence: 
+                item_index = self.add(item) 
+        except TypeError: 
+            raise ValueError( 
+                "Argument needs to be an iterable, got %s" % type(sequence) 
+            ) 
+        return item_index 
+ 
+    def index(self, key): 
+        """ 
+        Get the index of a given entry, raising an IndexError if it's not 
+        present. 
+ 
+        `key` can be an iterable of entries that is not a string, in which case 
+        this returns a list of indices. 
+ 
+        Example: 
+            >>> oset = OrderedSet([1, 2, 3]) 
+            >>> oset.index(2) 
+            1 
+        """ 
+        if is_iterable(key): 
+            return [self.index(subkey) for subkey in key] 
+        return self.map[key] 
+ 
+    # Provide some compatibility with pd.Index 
+    get_loc = index 
+    get_indexer = index 
+ 
+    def pop(self): 
+        """ 
+        Remove and return the last element from the set. 
+ 
+        Raises KeyError if the set is empty. 
+ 
+        Example: 
+            >>> oset = OrderedSet([1, 2, 3]) 
+            >>> oset.pop() 
+            3 
+        """ 
+        if not self.items: 
+            raise KeyError("Set is empty") 
+ 
+        elem = self.items[-1] 
+        del self.items[-1] 
+        del self.map[elem] 
+        return elem 
+ 
+    def discard(self, key): 
+        """ 
+        Remove an element.  Do not raise an exception if absent. 
+ 
+        The MutableSet mixin uses this to implement the .remove() method, which 
+        *does* raise an error when asked to remove a non-existent item. 
+ 
+        Example: 
+            >>> oset = OrderedSet([1, 2, 3]) 
+            >>> oset.discard(2) 
+            >>> print(oset) 
+            OrderedSet([1, 3]) 
+            >>> oset.discard(2) 
+            >>> print(oset) 
+            OrderedSet([1, 3]) 
+        """ 
+        if key in self: 
+            i = self.map[key] 
+            del self.items[i] 
+            del self.map[key] 
+            for k, v in self.map.items(): 
+                if v >= i: 
+                    self.map[k] = v - 1 
+ 
+    def clear(self): 
+        """ 
+        Remove all items from this OrderedSet. 
+        """ 
+        del self.items[:] 
+        self.map.clear() 
+ 
+    def __iter__(self): 
+        """ 
+        Example: 
+            >>> list(iter(OrderedSet([1, 2, 3]))) 
+            [1, 2, 3] 
+        """ 
+        return iter(self.items) 
+ 
+    def __reversed__(self): 
+        """ 
+        Example: 
+            >>> list(reversed(OrderedSet([1, 2, 3]))) 
+            [3, 2, 1] 
+        """ 
+        return reversed(self.items) 
+ 
+    def __repr__(self): 
+        if not self: 
+            return "%s()" % (self.__class__.__name__,) 
+        return "%s(%r)" % (self.__class__.__name__, list(self)) 
+ 
+    def __eq__(self, other): 
+        """ 
+        Returns true if the containers have the same items. If `other` is a 
+        Sequence, then order is checked, otherwise it is ignored. 
+ 
+        Example: 
+            >>> oset = OrderedSet([1, 3, 2]) 
+            >>> oset == [1, 3, 2] 
+            True 
+            >>> oset == [1, 2, 3] 
+            False 
+            >>> oset == [2, 3] 
+            False 
+            >>> oset == OrderedSet([3, 2, 1]) 
+            False 
+        """ 
+        # In Python 2 deque is not a Sequence, so treat it as one for 
+        # consistent behavior with Python 3. 
+        if isinstance(other, (Sequence, deque)): 
+            # Check that this OrderedSet contains the same elements, in the 
+            # same order, as the other object. 
+            return list(self) == list(other) 
+        try: 
+            other_as_set = set(other) 
+        except TypeError: 
+            # If `other` can't be converted into a set, it's not equal. 
+            return False 
+        else: 
+            return set(self) == other_as_set 
+ 
+    def union(self, *sets): 
+        """ 
+        Combines all unique items. 
+        Each items order is defined by its first appearance. 
+ 
+        Example: 
+            >>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0]) 
+            >>> print(oset) 
+            OrderedSet([3, 1, 4, 5, 2, 0]) 
+            >>> oset.union([8, 9]) 
+            OrderedSet([3, 1, 4, 5, 2, 0, 8, 9]) 
+            >>> oset | {10} 
+            OrderedSet([3, 1, 4, 5, 2, 0, 10]) 
+        """ 
+        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet 
+        containers = map(list, it.chain([self], sets)) 
+        items = it.chain.from_iterable(containers) 
+        return cls(items) 
+ 
+    def __and__(self, other): 
+        # the parent implementation of this is backwards 
+        return self.intersection(other) 
+ 
+    def intersection(self, *sets): 
+        """ 
+        Returns elements in common between all sets. Order is defined only 
+        by the first set. 
+ 
+        Example: 
+            >>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3]) 
+            >>> print(oset) 
+            OrderedSet([1, 2, 3]) 
+            >>> oset.intersection([2, 4, 5], [1, 2, 3, 4]) 
+            OrderedSet([2]) 
+            >>> oset.intersection() 
+            OrderedSet([1, 2, 3]) 
+        """ 
+        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet 
+        if sets: 
+            common = set.intersection(*map(set, sets)) 
+            items = (item for item in self if item in common) 
+        else: 
+            items = self 
+        return cls(items) 
+ 
+    def difference(self, *sets): 
+        """ 
+        Returns all elements that are in this set but not the others. 
+ 
+        Example: 
+            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2])) 
+            OrderedSet([1, 3]) 
+            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3])) 
+            OrderedSet([1]) 
+            >>> OrderedSet([1, 2, 3]) - OrderedSet([2]) 
+            OrderedSet([1, 3]) 
+            >>> OrderedSet([1, 2, 3]).difference() 
+            OrderedSet([1, 2, 3]) 
+        """ 
+        cls = self.__class__ 
+        if sets: 
+            other = set.union(*map(set, sets)) 
+            items = (item for item in self if item not in other) 
+        else: 
+            items = self 
+        return cls(items) 
+ 
+    def issubset(self, other): 
+        """ 
+        Report whether another set contains this set. 
+ 
+        Example: 
+            >>> OrderedSet([1, 2, 3]).issubset({1, 2}) 
+            False 
+            >>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4}) 
+            True 
+            >>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5}) 
+            False 
+        """ 
+        if len(self) > len(other):  # Fast check for obvious cases 
+            return False 
+        return all(item in other for item in self) 
+ 
+    def issuperset(self, other): 
+        """ 
+        Report whether this set contains another set. 
+ 
+        Example: 
+            >>> OrderedSet([1, 2]).issuperset([1, 2, 3]) 
+            False 
+            >>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3}) 
+            True 
+            >>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3}) 
+            False 
+        """ 
+        if len(self) < len(other):  # Fast check for obvious cases 
+            return False 
+        return all(item in self for item in other) 
+ 
+    def symmetric_difference(self, other): 
+        """ 
+        Return the symmetric difference of two OrderedSets as a new set. 
+        That is, the new set will contain all elements that are in exactly 
+        one of the sets. 
+ 
+        Their order will be preserved, with elements from `self` preceding 
+        elements from `other`. 
+ 
+        Example: 
+            >>> this = OrderedSet([1, 4, 3, 5, 7]) 
+            >>> other = OrderedSet([9, 7, 1, 3, 2]) 
+            >>> this.symmetric_difference(other) 
+            OrderedSet([4, 5, 9, 2]) 
+        """ 
+        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet 
+        diff1 = cls(self).difference(other) 
+        diff2 = cls(other).difference(self) 
+        return diff1.union(diff2) 
+ 
+    def _update_items(self, items): 
+        """ 
+        Replace the 'items' list of this OrderedSet with a new one, updating 
+        self.map accordingly. 
+        """ 
+        self.items = items 
+        self.map = {item: idx for (idx, item) in enumerate(items)} 
+ 
+    def difference_update(self, *sets): 
+        """ 
+        Update this OrderedSet to remove items from one or more other sets. 
+ 
+        Example: 
+            >>> this = OrderedSet([1, 2, 3]) 
+            >>> this.difference_update(OrderedSet([2, 4])) 
+            >>> print(this) 
+            OrderedSet([1, 3]) 
+ 
+            >>> this = OrderedSet([1, 2, 3, 4, 5]) 
+            >>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6])) 
+            >>> print(this) 
+            OrderedSet([3, 5]) 
+        """ 
+        items_to_remove = set() 
+        for other in sets: 
+            items_to_remove |= set(other) 
+        self._update_items([item for item in self.items if item not in items_to_remove]) 
+ 
+    def intersection_update(self, other): 
+        """ 
+        Update this OrderedSet to keep only items in another set, preserving 
+        their order in this set. 
+ 
+        Example: 
+            >>> this = OrderedSet([1, 4, 3, 5, 7]) 
+            >>> other = OrderedSet([9, 7, 1, 3, 2]) 
+            >>> this.intersection_update(other) 
+            >>> print(this) 
+            OrderedSet([1, 3, 7]) 
+        """ 
+        other = set(other) 
+        self._update_items([item for item in self.items if item in other]) 
+ 
+    def symmetric_difference_update(self, other): 
+        """ 
+        Update this OrderedSet to remove items from another set, then 
+        add items from the other set that were not present in this set. 
+ 
+        Example: 
+            >>> this = OrderedSet([1, 4, 3, 5, 7]) 
+            >>> other = OrderedSet([9, 7, 1, 3, 2]) 
+            >>> this.symmetric_difference_update(other) 
+            >>> print(this) 
+            OrderedSet([4, 5, 9, 2]) 
+        """ 
+        items_to_add = [item for item in other if item not in self] 
+        items_to_remove = set(other) 
+        self._update_items( 
+            [item for item in self.items if item not in items_to_remove] + items_to_add 
+        ) 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__about__.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__about__.py
index dc95138d04..4cabc108ed 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__about__.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__about__.py
@@ -1,27 +1,27 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-__all__ = [
-    "__title__",
-    "__summary__",
-    "__uri__",
-    "__version__",
-    "__author__",
-    "__email__",
-    "__license__",
-    "__copyright__",
-]
-
-__title__ = "packaging"
-__summary__ = "Core utilities for Python packages"
-__uri__ = "https://github.com/pypa/packaging"
-
-__version__ = "19.2"
-
-__author__ = "Donald Stufft and individual contributors"
-__email__ = "donald@stufft.io"
-
-__license__ = "BSD or Apache License, Version 2.0"
-__copyright__ = "Copyright 2014-2019 %s" % __author__
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+__all__ = [ 
+    "__title__", 
+    "__summary__", 
+    "__uri__", 
+    "__version__", 
+    "__author__", 
+    "__email__", 
+    "__license__", 
+    "__copyright__", 
+] 
+ 
+__title__ = "packaging" 
+__summary__ = "Core utilities for Python packages" 
+__uri__ = "https://github.com/pypa/packaging" 
+ 
+__version__ = "19.2" 
+ 
+__author__ = "Donald Stufft and individual contributors" 
+__email__ = "donald@stufft.io" 
+ 
+__license__ = "BSD or Apache License, Version 2.0" 
+__copyright__ = "Copyright 2014-2019 %s" % __author__ 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__init__.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__init__.py
index a0cf67df52..a058689c38 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__init__.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/__init__.py
@@ -1,26 +1,26 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-from .__about__ import (
-    __author__,
-    __copyright__,
-    __email__,
-    __license__,
-    __summary__,
-    __title__,
-    __uri__,
-    __version__,
-)
-
-__all__ = [
-    "__title__",
-    "__summary__",
-    "__uri__",
-    "__version__",
-    "__author__",
-    "__email__",
-    "__license__",
-    "__copyright__",
-]
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+from .__about__ import ( 
+    __author__, 
+    __copyright__, 
+    __email__, 
+    __license__, 
+    __summary__, 
+    __title__, 
+    __uri__, 
+    __version__, 
+) 
+ 
+__all__ = [ 
+    "__title__", 
+    "__summary__", 
+    "__uri__", 
+    "__version__", 
+    "__author__", 
+    "__email__", 
+    "__license__", 
+    "__copyright__", 
+] 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_compat.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_compat.py
index 25da473c19..8c3949b67a 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_compat.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_compat.py
@@ -1,31 +1,31 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import sys
-
-
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-
-# flake8: noqa
-
-if PY3:
-    string_types = (str,)
-else:
-    string_types = (basestring,)
-
-
-def with_metaclass(meta, *bases):
-    """
-    Create a base class with a metaclass.
-    """
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
-    class metaclass(meta):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-
-    return type.__new__(metaclass, "temporary_class", (), {})
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import sys 
+ 
+ 
+PY2 = sys.version_info[0] == 2 
+PY3 = sys.version_info[0] == 3 
+ 
+# flake8: noqa 
+ 
+if PY3: 
+    string_types = (str,) 
+else: 
+    string_types = (basestring,) 
+ 
+ 
+def with_metaclass(meta, *bases): 
+    """ 
+    Create a base class with a metaclass. 
+    """ 
+    # This requires a bit of explanation: the basic idea is to make a dummy 
+    # metaclass for one level of class instantiation that replaces itself with 
+    # the actual metaclass. 
+    class metaclass(meta): 
+        def __new__(cls, name, this_bases, d): 
+            return meta(name, bases, d) 
+ 
+    return type.__new__(metaclass, "temporary_class", (), {}) 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_structures.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_structures.py
index 68dcca634d..6dc7274d6a 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_structures.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/_structures.py
@@ -1,68 +1,68 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-
-class Infinity(object):
-    def __repr__(self):
-        return "Infinity"
-
-    def __hash__(self):
-        return hash(repr(self))
-
-    def __lt__(self, other):
-        return False
-
-    def __le__(self, other):
-        return False
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
-        return True
-
-    def __ge__(self, other):
-        return True
-
-    def __neg__(self):
-        return NegativeInfinity
-
-
-Infinity = Infinity()
-
-
-class NegativeInfinity(object):
-    def __repr__(self):
-        return "-Infinity"
-
-    def __hash__(self):
-        return hash(repr(self))
-
-    def __lt__(self, other):
-        return True
-
-    def __le__(self, other):
-        return True
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
-        return False
-
-    def __ge__(self, other):
-        return False
-
-    def __neg__(self):
-        return Infinity
-
-
-NegativeInfinity = NegativeInfinity()
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+ 
+class Infinity(object): 
+    def __repr__(self): 
+        return "Infinity" 
+ 
+    def __hash__(self): 
+        return hash(repr(self)) 
+ 
+    def __lt__(self, other): 
+        return False 
+ 
+    def __le__(self, other): 
+        return False 
+ 
+    def __eq__(self, other): 
+        return isinstance(other, self.__class__) 
+ 
+    def __ne__(self, other): 
+        return not isinstance(other, self.__class__) 
+ 
+    def __gt__(self, other): 
+        return True 
+ 
+    def __ge__(self, other): 
+        return True 
+ 
+    def __neg__(self): 
+        return NegativeInfinity 
+ 
+ 
+Infinity = Infinity() 
+ 
+ 
+class NegativeInfinity(object): 
+    def __repr__(self): 
+        return "-Infinity" 
+ 
+    def __hash__(self): 
+        return hash(repr(self)) 
+ 
+    def __lt__(self, other): 
+        return True 
+ 
+    def __le__(self, other): 
+        return True 
+ 
+    def __eq__(self, other): 
+        return isinstance(other, self.__class__) 
+ 
+    def __ne__(self, other): 
+        return not isinstance(other, self.__class__) 
+ 
+    def __gt__(self, other): 
+        return False 
+ 
+    def __ge__(self, other): 
+        return False 
+ 
+    def __neg__(self): 
+        return Infinity 
+ 
+ 
+NegativeInfinity = NegativeInfinity() 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/markers.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/markers.py
index 4bdfdb24f2..931cc54771 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/markers.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/markers.py
@@ -1,296 +1,296 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import operator
-import os
-import platform
-import sys
-
-from setuptools.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd
-from setuptools.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString
-from setuptools.extern.pyparsing import Literal as L  # noqa
-
-from ._compat import string_types
-from .specifiers import Specifier, InvalidSpecifier
-
-
-__all__ = [
-    "InvalidMarker",
-    "UndefinedComparison",
-    "UndefinedEnvironmentName",
-    "Marker",
-    "default_environment",
-]
-
-
-class InvalidMarker(ValueError):
-    """
-    An invalid marker was found, users should refer to PEP 508.
-    """
-
-
-class UndefinedComparison(ValueError):
-    """
-    An invalid operation was attempted on a value that doesn't support it.
-    """
-
-
-class UndefinedEnvironmentName(ValueError):
-    """
-    A name was attempted to be used that does not exist inside of the
-    environment.
-    """
-
-
-class Node(object):
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return str(self.value)
-
-    def __repr__(self):
-        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
-
-    def serialize(self):
-        raise NotImplementedError
-
-
-class Variable(Node):
-    def serialize(self):
-        return str(self)
-
-
-class Value(Node):
-    def serialize(self):
-        return '"{0}"'.format(self)
-
-
-class Op(Node):
-    def serialize(self):
-        return str(self)
-
-
-VARIABLE = (
-    L("implementation_version")
-    | L("platform_python_implementation")
-    | L("implementation_name")
-    | L("python_full_version")
-    | L("platform_release")
-    | L("platform_version")
-    | L("platform_machine")
-    | L("platform_system")
-    | L("python_version")
-    | L("sys_platform")
-    | L("os_name")
-    | L("os.name")
-    | L("sys.platform")  # PEP-345
-    | L("platform.version")  # PEP-345
-    | L("platform.machine")  # PEP-345
-    | L("platform.python_implementation")  # PEP-345
-    | L("python_implementation")  # PEP-345
-    | L("extra")  # undocumented setuptools legacy
-)
-ALIASES = {
-    "os.name": "os_name",
-    "sys.platform": "sys_platform",
-    "platform.version": "platform_version",
-    "platform.machine": "platform_machine",
-    "platform.python_implementation": "platform_python_implementation",
-    "python_implementation": "platform_python_implementation",
-}
-VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
-
-VERSION_CMP = (
-    L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
-)
-
-MARKER_OP = VERSION_CMP | L("not in") | L("in")
-MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
-
-MARKER_VALUE = QuotedString("'") | QuotedString('"')
-MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
-
-BOOLOP = L("and") | L("or")
-
-MARKER_VAR = VARIABLE | MARKER_VALUE
-
-MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
-MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
-
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-
-MARKER_EXPR = Forward()
-MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
-MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
-
-MARKER = stringStart + MARKER_EXPR + stringEnd
-
-
-def _coerce_parse_result(results):
-    if isinstance(results, ParseResults):
-        return [_coerce_parse_result(i) for i in results]
-    else:
-        return results
-
-
-def _format_marker(marker, first=True):
-    assert isinstance(marker, (list, tuple, string_types))
-
-    # Sometimes we have a structure like [[...]] which is a single item list
-    # where the single item is itself it's own list. In that case we want skip
-    # the rest of this function so that we don't get extraneous () on the
-    # outside.
-    if (
-        isinstance(marker, list)
-        and len(marker) == 1
-        and isinstance(marker[0], (list, tuple))
-    ):
-        return _format_marker(marker[0])
-
-    if isinstance(marker, list):
-        inner = (_format_marker(m, first=False) for m in marker)
-        if first:
-            return " ".join(inner)
-        else:
-            return "(" + " ".join(inner) + ")"
-    elif isinstance(marker, tuple):
-        return " ".join([m.serialize() for m in marker])
-    else:
-        return marker
-
-
-_operators = {
-    "in": lambda lhs, rhs: lhs in rhs,
-    "not in": lambda lhs, rhs: lhs not in rhs,
-    "<": operator.lt,
-    "<=": operator.le,
-    "==": operator.eq,
-    "!=": operator.ne,
-    ">=": operator.ge,
-    ">": operator.gt,
-}
-
-
-def _eval_op(lhs, op, rhs):
-    try:
-        spec = Specifier("".join([op.serialize(), rhs]))
-    except InvalidSpecifier:
-        pass
-    else:
-        return spec.contains(lhs)
-
-    oper = _operators.get(op.serialize())
-    if oper is None:
-        raise UndefinedComparison(
-            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
-        )
-
-    return oper(lhs, rhs)
-
-
-_undefined = object()
-
-
-def _get_env(environment, name):
-    value = environment.get(name, _undefined)
-
-    if value is _undefined:
-        raise UndefinedEnvironmentName(
-            "{0!r} does not exist in evaluation environment.".format(name)
-        )
-
-    return value
-
-
-def _evaluate_markers(markers, environment):
-    groups = [[]]
-
-    for marker in markers:
-        assert isinstance(marker, (list, tuple, string_types))
-
-        if isinstance(marker, list):
-            groups[-1].append(_evaluate_markers(marker, environment))
-        elif isinstance(marker, tuple):
-            lhs, op, rhs = marker
-
-            if isinstance(lhs, Variable):
-                lhs_value = _get_env(environment, lhs.value)
-                rhs_value = rhs.value
-            else:
-                lhs_value = lhs.value
-                rhs_value = _get_env(environment, rhs.value)
-
-            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
-        else:
-            assert marker in ["and", "or"]
-            if marker == "or":
-                groups.append([])
-
-    return any(all(item) for item in groups)
-
-
-def format_full_version(info):
-    version = "{0.major}.{0.minor}.{0.micro}".format(info)
-    kind = info.releaselevel
-    if kind != "final":
-        version += kind[0] + str(info.serial)
-    return version
-
-
-def default_environment():
-    if hasattr(sys, "implementation"):
-        iver = format_full_version(sys.implementation.version)
-        implementation_name = sys.implementation.name
-    else:
-        iver = "0"
-        implementation_name = ""
-
-    return {
-        "implementation_name": implementation_name,
-        "implementation_version": iver,
-        "os_name": os.name,
-        "platform_machine": platform.machine(),
-        "platform_release": platform.release(),
-        "platform_system": platform.system(),
-        "platform_version": platform.version(),
-        "python_full_version": platform.python_version(),
-        "platform_python_implementation": platform.python_implementation(),
-        "python_version": ".".join(platform.python_version_tuple()[:2]),
-        "sys_platform": sys.platform,
-    }
-
-
-class Marker(object):
-    def __init__(self, marker):
-        try:
-            self._markers = _coerce_parse_result(MARKER.parseString(marker))
-        except ParseException as e:
-            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
-                marker, marker[e.loc : e.loc + 8]
-            )
-            raise InvalidMarker(err_str)
-
-    def __str__(self):
-        return _format_marker(self._markers)
-
-    def __repr__(self):
-        return "<Marker({0!r})>".format(str(self))
-
-    def evaluate(self, environment=None):
-        """Evaluate a marker.
-
-        Return the boolean from evaluating the given marker against the
-        environment. environment is an optional argument to override all or
-        part of the determined environment.
-
-        The environment is determined from the current Python process.
-        """
-        current_environment = default_environment()
-        if environment is not None:
-            current_environment.update(environment)
-
-        return _evaluate_markers(self._markers, current_environment)
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import operator 
+import os 
+import platform 
+import sys 
+ 
+from setuptools.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd 
+from setuptools.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString 
+from setuptools.extern.pyparsing import Literal as L  # noqa 
+ 
+from ._compat import string_types 
+from .specifiers import Specifier, InvalidSpecifier 
+ 
+ 
+__all__ = [ 
+    "InvalidMarker", 
+    "UndefinedComparison", 
+    "UndefinedEnvironmentName", 
+    "Marker", 
+    "default_environment", 
+] 
+ 
+ 
+class InvalidMarker(ValueError): 
+    """ 
+    An invalid marker was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+class UndefinedComparison(ValueError): 
+    """ 
+    An invalid operation was attempted on a value that doesn't support it. 
+    """ 
+ 
+ 
+class UndefinedEnvironmentName(ValueError): 
+    """ 
+    A name was attempted to be used that does not exist inside of the 
+    environment. 
+    """ 
+ 
+ 
+class Node(object): 
+    def __init__(self, value): 
+        self.value = value 
+ 
+    def __str__(self): 
+        return str(self.value) 
+ 
+    def __repr__(self): 
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self)) 
+ 
+    def serialize(self): 
+        raise NotImplementedError 
+ 
+ 
+class Variable(Node): 
+    def serialize(self): 
+        return str(self) 
+ 
+ 
+class Value(Node): 
+    def serialize(self): 
+        return '"{0}"'.format(self) 
+ 
+ 
+class Op(Node): 
+    def serialize(self): 
+        return str(self) 
+ 
+ 
+VARIABLE = ( 
+    L("implementation_version") 
+    | L("platform_python_implementation") 
+    | L("implementation_name") 
+    | L("python_full_version") 
+    | L("platform_release") 
+    | L("platform_version") 
+    | L("platform_machine") 
+    | L("platform_system") 
+    | L("python_version") 
+    | L("sys_platform") 
+    | L("os_name") 
+    | L("os.name") 
+    | L("sys.platform")  # PEP-345 
+    | L("platform.version")  # PEP-345 
+    | L("platform.machine")  # PEP-345 
+    | L("platform.python_implementation")  # PEP-345 
+    | L("python_implementation")  # PEP-345 
+    | L("extra")  # undocumented setuptools legacy 
+) 
+ALIASES = { 
+    "os.name": "os_name", 
+    "sys.platform": "sys_platform", 
+    "platform.version": "platform_version", 
+    "platform.machine": "platform_machine", 
+    "platform.python_implementation": "platform_python_implementation", 
+    "python_implementation": "platform_python_implementation", 
+} 
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0]))) 
+ 
+VERSION_CMP = ( 
+    L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<") 
+) 
+ 
+MARKER_OP = VERSION_CMP | L("not in") | L("in") 
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0])) 
+ 
+MARKER_VALUE = QuotedString("'") | QuotedString('"') 
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0])) 
+ 
+BOOLOP = L("and") | L("or") 
+ 
+MARKER_VAR = VARIABLE | MARKER_VALUE 
+ 
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR) 
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0])) 
+ 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+ 
+MARKER_EXPR = Forward() 
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN) 
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR) 
+ 
+MARKER = stringStart + MARKER_EXPR + stringEnd 
+ 
+ 
+def _coerce_parse_result(results): 
+    if isinstance(results, ParseResults): 
+        return [_coerce_parse_result(i) for i in results] 
+    else: 
+        return results 
+ 
+ 
+def _format_marker(marker, first=True): 
+    assert isinstance(marker, (list, tuple, string_types)) 
+ 
+    # Sometimes we have a structure like [[...]] which is a single item list 
+    # where the single item is itself it's own list. In that case we want skip 
+    # the rest of this function so that we don't get extraneous () on the 
+    # outside. 
+    if ( 
+        isinstance(marker, list) 
+        and len(marker) == 1 
+        and isinstance(marker[0], (list, tuple)) 
+    ): 
+        return _format_marker(marker[0]) 
+ 
+    if isinstance(marker, list): 
+        inner = (_format_marker(m, first=False) for m in marker) 
+        if first: 
+            return " ".join(inner) 
+        else: 
+            return "(" + " ".join(inner) + ")" 
+    elif isinstance(marker, tuple): 
+        return " ".join([m.serialize() for m in marker]) 
+    else: 
+        return marker 
+ 
+ 
+_operators = { 
+    "in": lambda lhs, rhs: lhs in rhs, 
+    "not in": lambda lhs, rhs: lhs not in rhs, 
+    "<": operator.lt, 
+    "<=": operator.le, 
+    "==": operator.eq, 
+    "!=": operator.ne, 
+    ">=": operator.ge, 
+    ">": operator.gt, 
+} 
+ 
+ 
+def _eval_op(lhs, op, rhs): 
+    try: 
+        spec = Specifier("".join([op.serialize(), rhs])) 
+    except InvalidSpecifier: 
+        pass 
+    else: 
+        return spec.contains(lhs) 
+ 
+    oper = _operators.get(op.serialize()) 
+    if oper is None: 
+        raise UndefinedComparison( 
+            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs) 
+        ) 
+ 
+    return oper(lhs, rhs) 
+ 
+ 
+_undefined = object() 
+ 
+ 
+def _get_env(environment, name): 
+    value = environment.get(name, _undefined) 
+ 
+    if value is _undefined: 
+        raise UndefinedEnvironmentName( 
+            "{0!r} does not exist in evaluation environment.".format(name) 
+        ) 
+ 
+    return value 
+ 
+ 
+def _evaluate_markers(markers, environment): 
+    groups = [[]] 
+ 
+    for marker in markers: 
+        assert isinstance(marker, (list, tuple, string_types)) 
+ 
+        if isinstance(marker, list): 
+            groups[-1].append(_evaluate_markers(marker, environment)) 
+        elif isinstance(marker, tuple): 
+            lhs, op, rhs = marker 
+ 
+            if isinstance(lhs, Variable): 
+                lhs_value = _get_env(environment, lhs.value) 
+                rhs_value = rhs.value 
+            else: 
+                lhs_value = lhs.value 
+                rhs_value = _get_env(environment, rhs.value) 
+ 
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value)) 
+        else: 
+            assert marker in ["and", "or"] 
+            if marker == "or": 
+                groups.append([]) 
+ 
+    return any(all(item) for item in groups) 
+ 
+ 
+def format_full_version(info): 
+    version = "{0.major}.{0.minor}.{0.micro}".format(info) 
+    kind = info.releaselevel 
+    if kind != "final": 
+        version += kind[0] + str(info.serial) 
+    return version 
+ 
+ 
+def default_environment(): 
+    if hasattr(sys, "implementation"): 
+        iver = format_full_version(sys.implementation.version) 
+        implementation_name = sys.implementation.name 
+    else: 
+        iver = "0" 
+        implementation_name = "" 
+ 
+    return { 
+        "implementation_name": implementation_name, 
+        "implementation_version": iver, 
+        "os_name": os.name, 
+        "platform_machine": platform.machine(), 
+        "platform_release": platform.release(), 
+        "platform_system": platform.system(), 
+        "platform_version": platform.version(), 
+        "python_full_version": platform.python_version(), 
+        "platform_python_implementation": platform.python_implementation(), 
+        "python_version": ".".join(platform.python_version_tuple()[:2]), 
+        "sys_platform": sys.platform, 
+    } 
+ 
+ 
+class Marker(object): 
+    def __init__(self, marker): 
+        try: 
+            self._markers = _coerce_parse_result(MARKER.parseString(marker)) 
+        except ParseException as e: 
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format( 
+                marker, marker[e.loc : e.loc + 8] 
+            ) 
+            raise InvalidMarker(err_str) 
+ 
+    def __str__(self): 
+        return _format_marker(self._markers) 
+ 
+    def __repr__(self): 
+        return "<Marker({0!r})>".format(str(self)) 
+ 
+    def evaluate(self, environment=None): 
+        """Evaluate a marker. 
+ 
+        Return the boolean from evaluating the given marker against the 
+        environment. environment is an optional argument to override all or 
+        part of the determined environment. 
+ 
+        The environment is determined from the current Python process. 
+        """ 
+        current_environment = default_environment() 
+        if environment is not None: 
+            current_environment.update(environment) 
+ 
+        return _evaluate_markers(self._markers, current_environment) 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/requirements.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/requirements.py
index 8a0c2cb9be..2574894757 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/requirements.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/requirements.py
@@ -1,138 +1,138 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import string
-import re
-
-from setuptools.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
-from setuptools.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
-from setuptools.extern.pyparsing import Literal as L  # noqa
-from setuptools.extern.six.moves.urllib import parse as urlparse
-
-from .markers import MARKER_EXPR, Marker
-from .specifiers import LegacySpecifier, Specifier, SpecifierSet
-
-
-class InvalidRequirement(ValueError):
-    """
-    An invalid requirement was found, users should refer to PEP 508.
-    """
-
-
-ALPHANUM = Word(string.ascii_letters + string.digits)
-
-LBRACKET = L("[").suppress()
-RBRACKET = L("]").suppress()
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-COMMA = L(",").suppress()
-SEMICOLON = L(";").suppress()
-AT = L("@").suppress()
-
-PUNCTUATION = Word("-_.")
-IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
-IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
-
-NAME = IDENTIFIER("name")
-EXTRA = IDENTIFIER
-
-URI = Regex(r"[^ ]+")("url")
-URL = AT + URI
-
-EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
-EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
-
-VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
-VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
-
-VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
-VERSION_MANY = Combine(
-    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
-)("_raw_spec")
-_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
-_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
-
-VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
-VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
-
-MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
-MARKER_EXPR.setParseAction(
-    lambda s, l, t: Marker(s[t._original_start : t._original_end])
-)
-MARKER_SEPARATOR = SEMICOLON
-MARKER = MARKER_SEPARATOR + MARKER_EXPR
-
-VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
-URL_AND_MARKER = URL + Optional(MARKER)
-
-NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
-
-REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
-# setuptools.extern.pyparsing isn't thread safe during initialization, so we do it eagerly, see
-# issue #104
-REQUIREMENT.parseString("x[]")
-
-
-class Requirement(object):
-    """Parse a requirement.
-
-    Parse a given requirement string into its parts, such as name, specifier,
-    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
-    string.
-    """
-
-    # TODO: Can we test whether something is contained within a requirement?
-    #       If so how do we do that? Do we need to test against the _name_ of
-    #       the thing as well as the version? What about the markers?
-    # TODO: Can we normalize the name and extra name?
-
-    def __init__(self, requirement_string):
-        try:
-            req = REQUIREMENT.parseString(requirement_string)
-        except ParseException as e:
-            raise InvalidRequirement(
-                'Parse error at "{0!r}": {1}'.format(
-                    requirement_string[e.loc : e.loc + 8], e.msg
-                )
-            )
-
-        self.name = req.name
-        if req.url:
-            parsed_url = urlparse.urlparse(req.url)
-            if parsed_url.scheme == "file":
-                if urlparse.urlunparse(parsed_url) != req.url:
-                    raise InvalidRequirement("Invalid URL given")
-            elif not (parsed_url.scheme and parsed_url.netloc) or (
-                not parsed_url.scheme and not parsed_url.netloc
-            ):
-                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
-            self.url = req.url
-        else:
-            self.url = None
-        self.extras = set(req.extras.asList() if req.extras else [])
-        self.specifier = SpecifierSet(req.specifier)
-        self.marker = req.marker if req.marker else None
-
-    def __str__(self):
-        parts = [self.name]
-
-        if self.extras:
-            parts.append("[{0}]".format(",".join(sorted(self.extras))))
-
-        if self.specifier:
-            parts.append(str(self.specifier))
-
-        if self.url:
-            parts.append("@ {0}".format(self.url))
-            if self.marker:
-                parts.append(" ")
-
-        if self.marker:
-            parts.append("; {0}".format(self.marker))
-
-        return "".join(parts)
-
-    def __repr__(self):
-        return "<Requirement({0!r})>".format(str(self))
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import string 
+import re 
+ 
+from setuptools.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException 
+from setuptools.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine 
+from setuptools.extern.pyparsing import Literal as L  # noqa 
+from setuptools.extern.six.moves.urllib import parse as urlparse 
+ 
+from .markers import MARKER_EXPR, Marker 
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet 
+ 
+ 
+class InvalidRequirement(ValueError): 
+    """ 
+    An invalid requirement was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+ALPHANUM = Word(string.ascii_letters + string.digits) 
+ 
+LBRACKET = L("[").suppress() 
+RBRACKET = L("]").suppress() 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+COMMA = L(",").suppress() 
+SEMICOLON = L(";").suppress() 
+AT = L("@").suppress() 
+ 
+PUNCTUATION = Word("-_.") 
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM) 
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END)) 
+ 
+NAME = IDENTIFIER("name") 
+EXTRA = IDENTIFIER 
+ 
+URI = Regex(r"[^ ]+")("url") 
+URL = AT + URI 
+ 
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA) 
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras") 
+ 
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+ 
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY 
+VERSION_MANY = Combine( 
+    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False 
+)("_raw_spec") 
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY)) 
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "") 
+ 
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier") 
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1]) 
+ 
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker") 
+MARKER_EXPR.setParseAction( 
+    lambda s, l, t: Marker(s[t._original_start : t._original_end]) 
+) 
+MARKER_SEPARATOR = SEMICOLON 
+MARKER = MARKER_SEPARATOR + MARKER_EXPR 
+ 
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER) 
+URL_AND_MARKER = URL + Optional(MARKER) 
+ 
+NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER) 
+ 
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd 
+# setuptools.extern.pyparsing isn't thread safe during initialization, so we do it eagerly, see 
+# issue #104 
+REQUIREMENT.parseString("x[]") 
+ 
+ 
+class Requirement(object): 
+    """Parse a requirement. 
+ 
+    Parse a given requirement string into its parts, such as name, specifier, 
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement 
+    string. 
+    """ 
+ 
+    # TODO: Can we test whether something is contained within a requirement? 
+    #       If so how do we do that? Do we need to test against the _name_ of 
+    #       the thing as well as the version? What about the markers? 
+    # TODO: Can we normalize the name and extra name? 
+ 
+    def __init__(self, requirement_string): 
+        try: 
+            req = REQUIREMENT.parseString(requirement_string) 
+        except ParseException as e: 
+            raise InvalidRequirement( 
+                'Parse error at "{0!r}": {1}'.format( 
+                    requirement_string[e.loc : e.loc + 8], e.msg 
+                ) 
+            ) 
+ 
+        self.name = req.name 
+        if req.url: 
+            parsed_url = urlparse.urlparse(req.url) 
+            if parsed_url.scheme == "file": 
+                if urlparse.urlunparse(parsed_url) != req.url: 
+                    raise InvalidRequirement("Invalid URL given") 
+            elif not (parsed_url.scheme and parsed_url.netloc) or ( 
+                not parsed_url.scheme and not parsed_url.netloc 
+            ): 
+                raise InvalidRequirement("Invalid URL: {0}".format(req.url)) 
+            self.url = req.url 
+        else: 
+            self.url = None 
+        self.extras = set(req.extras.asList() if req.extras else []) 
+        self.specifier = SpecifierSet(req.specifier) 
+        self.marker = req.marker if req.marker else None 
+ 
+    def __str__(self): 
+        parts = [self.name] 
+ 
+        if self.extras: 
+            parts.append("[{0}]".format(",".join(sorted(self.extras)))) 
+ 
+        if self.specifier: 
+            parts.append(str(self.specifier)) 
+ 
+        if self.url: 
+            parts.append("@ {0}".format(self.url)) 
+            if self.marker: 
+                parts.append(" ") 
+ 
+        if self.marker: 
+            parts.append("; {0}".format(self.marker)) 
+ 
+        return "".join(parts) 
+ 
+    def __repr__(self): 
+        return "<Requirement({0!r})>".format(str(self)) 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/specifiers.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/specifiers.py
index 743576a080..1e9d2f48da 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/specifiers.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/specifiers.py
@@ -1,749 +1,749 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import abc
-import functools
-import itertools
-import re
-
-from ._compat import string_types, with_metaclass
-from .version import Version, LegacyVersion, parse
-
-
-class InvalidSpecifier(ValueError):
-    """
-    An invalid specifier was found, users should refer to PEP 440.
-    """
-
-
-class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):
-    @abc.abstractmethod
-    def __str__(self):
-        """
-        Returns the str representation of this Specifier like object. This
-        should be representative of the Specifier itself.
-        """
-
-    @abc.abstractmethod
-    def __hash__(self):
-        """
-        Returns a hash value for this Specifier like object.
-        """
-
-    @abc.abstractmethod
-    def __eq__(self, other):
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are equal.
-        """
-
-    @abc.abstractmethod
-    def __ne__(self, other):
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are not equal.
-        """
-
-    @abc.abstractproperty
-    def prereleases(self):
-        """
-        Returns whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @prereleases.setter
-    def prereleases(self, value):
-        """
-        Sets whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @abc.abstractmethod
-    def contains(self, item, prereleases=None):
-        """
-        Determines if the given item is contained within this specifier.
-        """
-
-    @abc.abstractmethod
-    def filter(self, iterable, prereleases=None):
-        """
-        Takes an iterable of items and filters them so that only items which
-        are contained within this specifier are allowed in it.
-        """
-
-
-class _IndividualSpecifier(BaseSpecifier):
-
-    _operators = {}
-
-    def __init__(self, spec="", prereleases=None):
-        match = self._regex.search(spec)
-        if not match:
-            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
-
-        self._spec = (match.group("operator").strip(), match.group("version").strip())
-
-        # Store whether or not this Specifier should accept prereleases
-        self._prereleases = prereleases
-
-    def __repr__(self):
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
-        return "<{0}({1!r}{2})>".format(self.__class__.__name__, str(self), pre)
-
-    def __str__(self):
-        return "{0}{1}".format(*self._spec)
-
-    def __hash__(self):
-        return hash(self._spec)
-
-    def __eq__(self, other):
-        if isinstance(other, string_types):
-            try:
-                other = self.__class__(other)
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._spec == other._spec
-
-    def __ne__(self, other):
-        if isinstance(other, string_types):
-            try:
-                other = self.__class__(other)
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._spec != other._spec
-
-    def _get_operator(self, op):
-        return getattr(self, "_compare_{0}".format(self._operators[op]))
-
-    def _coerce_version(self, version):
-        if not isinstance(version, (LegacyVersion, Version)):
-            version = parse(version)
-        return version
-
-    @property
-    def operator(self):
-        return self._spec[0]
-
-    @property
-    def version(self):
-        return self._spec[1]
-
-    @property
-    def prereleases(self):
-        return self._prereleases
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-    def __contains__(self, item):
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
-        # Determine if prereleases are to be allowed or not.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # Normalize item to a Version or LegacyVersion, this allows us to have
-        # a shortcut for ``"2.0" in Specifier(">=2")
-        item = self._coerce_version(item)
-
-        # Determine if we should be supporting prereleases in this specifier
-        # or not, if we do not support prereleases than we can short circuit
-        # logic if this version is a prereleases.
-        if item.is_prerelease and not prereleases:
-            return False
-
-        # Actually do the comparison to determine if this item is contained
-        # within this Specifier or not.
-        return self._get_operator(self.operator)(item, self.version)
-
-    def filter(self, iterable, prereleases=None):
-        yielded = False
-        found_prereleases = []
-
-        kw = {"prereleases": prereleases if prereleases is not None else True}
-
-        # Attempt to iterate over all the values in the iterable and if any of
-        # them match, yield them.
-        for version in iterable:
-            parsed_version = self._coerce_version(version)
-
-            if self.contains(parsed_version, **kw):
-                # If our version is a prerelease, and we were not set to allow
-                # prereleases, then we'll store it for later incase nothing
-                # else matches this specifier.
-                if parsed_version.is_prerelease and not (
-                    prereleases or self.prereleases
-                ):
-                    found_prereleases.append(version)
-                # Either this is not a prerelease, or we should have been
-                # accepting prereleases from the beginning.
-                else:
-                    yielded = True
-                    yield version
-
-        # Now that we've iterated over everything, determine if we've yielded
-        # any values, and if we have not and we have any prereleases stored up
-        # then we will go ahead and yield the prereleases.
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
-
-
-class LegacySpecifier(_IndividualSpecifier):
-
-    _regex_str = r"""
-        (?P<operator>(==|!=|<=|>=|<|>))
-        \s*
-        (?P<version>
-            [^,;\s)]* # Since this is a "legacy" specifier, and the version
-                      # string can be just about anything, we match everything
-                      # except for whitespace, a semi-colon for marker support,
-                      # a closing paren since versions can be enclosed in
-                      # them, and a comma since it's a version separator.
-        )
-        """
-
-    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-    }
-
-    def _coerce_version(self, version):
-        if not isinstance(version, LegacyVersion):
-            version = LegacyVersion(str(version))
-        return version
-
-    def _compare_equal(self, prospective, spec):
-        return prospective == self._coerce_version(spec)
-
-    def _compare_not_equal(self, prospective, spec):
-        return prospective != self._coerce_version(spec)
-
-    def _compare_less_than_equal(self, prospective, spec):
-        return prospective <= self._coerce_version(spec)
-
-    def _compare_greater_than_equal(self, prospective, spec):
-        return prospective >= self._coerce_version(spec)
-
-    def _compare_less_than(self, prospective, spec):
-        return prospective < self._coerce_version(spec)
-
-    def _compare_greater_than(self, prospective, spec):
-        return prospective > self._coerce_version(spec)
-
-
-def _require_version_compare(fn):
-    @functools.wraps(fn)
-    def wrapped(self, prospective, spec):
-        if not isinstance(prospective, Version):
-            return False
-        return fn(self, prospective, spec)
-
-    return wrapped
-
-
-class Specifier(_IndividualSpecifier):
-
-    _regex_str = r"""
-        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
-        (?P<version>
-            (?:
-                # The identity operators allow for an escape hatch that will
-                # do an exact string match of the version you wish to install.
-                # This will not be parsed by PEP 440 and we cannot determine
-                # any semantic meaning from it. This operator is discouraged
-                # but included entirely as an escape hatch.
-                (?<====)  # Only match for the identity operator
-                \s*
-                [^\s]*    # We just match everything, except for whitespace
-                          # since we are only testing for strict identity.
-            )
-            |
-            (?:
-                # The (non)equality operators allow for wild card and local
-                # versions to be specified so we have to define these two
-                # operators separately to enable that.
-                (?<===|!=)            # Only match for equals and not equals
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-
-                # You cannot use a wild card and a dev or local version
-                # together so group them with a | and make them optional.
-                (?:
-                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
-                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
-                    |
-                    \.\*  # Wild card syntax of .*
-                )?
-            )
-            |
-            (?:
-                # The compatible operator requires at least two digits in the
-                # release segment.
-                (?<=~=)               # Only match for the compatible operator
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-            |
-            (?:
-                # All other operators only allow a sub set of what the
-                # (non)equality operators do. Specifically they do not allow
-                # local versions to be specified nor do they allow the prefix
-                # matching wild cards.
-                (?<!==|!=|~=)         # We have special cases for these
-                                      # operators so we want to make sure they
-                                      # don't match here.
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-        )
-        """
-
-    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "~=": "compatible",
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-        "===": "arbitrary",
-    }
-
-    @_require_version_compare
-    def _compare_compatible(self, prospective, spec):
-        # Compatible releases have an equivalent combination of >= and ==. That
-        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
-        # implement this in terms of the other specifiers instead of
-        # implementing it ourselves. The only thing we need to do is construct
-        # the other specifiers.
-
-        # We want everything but the last item in the version, but we want to
-        # ignore post and dev releases and we want to treat the pre-release as
-        # it's own separate segment.
-        prefix = ".".join(
-            list(
-                itertools.takewhile(
-                    lambda x: (not x.startswith("post") and not x.startswith("dev")),
-                    _version_split(spec),
-                )
-            )[:-1]
-        )
-
-        # Add the prefix notation to the end of our string
-        prefix += ".*"
-
-        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
-            prospective, prefix
-        )
-
-    @_require_version_compare
-    def _compare_equal(self, prospective, spec):
-        # We need special logic to handle prefix matching
-        if spec.endswith(".*"):
-            # In the case of prefix matching we want to ignore local segment.
-            prospective = Version(prospective.public)
-            # Split the spec out by dots, and pretend that there is an implicit
-            # dot in between a release segment and a pre-release segment.
-            spec = _version_split(spec[:-2])  # Remove the trailing .*
-
-            # Split the prospective version out by dots, and pretend that there
-            # is an implicit dot in between a release segment and a pre-release
-            # segment.
-            prospective = _version_split(str(prospective))
-
-            # Shorten the prospective version to be the same length as the spec
-            # so that we can determine if the specifier is a prefix of the
-            # prospective version or not.
-            prospective = prospective[: len(spec)]
-
-            # Pad out our two sides with zeros so that they both equal the same
-            # length.
-            spec, prospective = _pad_version(spec, prospective)
-        else:
-            # Convert our spec string into a Version
-            spec = Version(spec)
-
-            # If the specifier does not have a local segment, then we want to
-            # act as if the prospective version also does not have a local
-            # segment.
-            if not spec.local:
-                prospective = Version(prospective.public)
-
-        return prospective == spec
-
-    @_require_version_compare
-    def _compare_not_equal(self, prospective, spec):
-        return not self._compare_equal(prospective, spec)
-
-    @_require_version_compare
-    def _compare_less_than_equal(self, prospective, spec):
-        return prospective <= Version(spec)
-
-    @_require_version_compare
-    def _compare_greater_than_equal(self, prospective, spec):
-        return prospective >= Version(spec)
-
-    @_require_version_compare
-    def _compare_less_than(self, prospective, spec):
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec)
-
-        # Check to see if the prospective version is less than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective < spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a pre-release version, that we do not accept pre-release
-        # versions for the version mentioned in the specifier (e.g. <3.1 should
-        # not match 3.1.dev0, but should match 3.0.dev0).
-        if not spec.is_prerelease and prospective.is_prerelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # less than the spec version *and* it's not a pre-release of the same
-        # version in the spec.
-        return True
-
-    @_require_version_compare
-    def _compare_greater_than(self, prospective, spec):
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec)
-
-        # Check to see if the prospective version is greater than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective > spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a post-release version, that we do not accept
-        # post-release versions for the version mentioned in the specifier
-        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
-        if not spec.is_postrelease and prospective.is_postrelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # Ensure that we do not allow a local version of the version mentioned
-        # in the specifier, which is technically greater than, to match.
-        if prospective.local is not None:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # greater than the spec version *and* it's not a pre-release of the
-        # same version in the spec.
-        return True
-
-    def _compare_arbitrary(self, prospective, spec):
-        return str(prospective).lower() == str(spec).lower()
-
-    @property
-    def prereleases(self):
-        # If there is an explicit prereleases set for this, then we'll just
-        # blindly use that.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # Look at all of our specifiers and determine if they are inclusive
-        # operators, and if they are if they are including an explicit
-        # prerelease.
-        operator, version = self._spec
-        if operator in ["==", ">=", "<=", "~=", "==="]:
-            # The == specifier can include a trailing .*, if it does we
-            # want to remove before parsing.
-            if operator == "==" and version.endswith(".*"):
-                version = version[:-2]
-
-            # Parse the version, and if it is a pre-release than this
-            # specifier allows pre-releases.
-            if parse(version).is_prerelease:
-                return True
-
-        return False
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-
-_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
-
-
-def _version_split(version):
-    result = []
-    for item in version.split("."):
-        match = _prefix_regex.search(item)
-        if match:
-            result.extend(match.groups())
-        else:
-            result.append(item)
-    return result
-
-
-def _pad_version(left, right):
-    left_split, right_split = [], []
-
-    # Get the release segment of our versions
-    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
-    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
-
-    # Get the rest of our versions
-    left_split.append(left[len(left_split[0]) :])
-    right_split.append(right[len(right_split[0]) :])
-
-    # Insert our padding
-    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
-    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
-
-    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
-
-
-class SpecifierSet(BaseSpecifier):
-    def __init__(self, specifiers="", prereleases=None):
-        # Split on , to break each indidivual specifier into it's own item, and
-        # strip each item to remove leading/trailing whitespace.
-        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
-
-        # Parsed each individual specifier, attempting first to make it a
-        # Specifier and falling back to a LegacySpecifier.
-        parsed = set()
-        for specifier in specifiers:
-            try:
-                parsed.add(Specifier(specifier))
-            except InvalidSpecifier:
-                parsed.add(LegacySpecifier(specifier))
-
-        # Turn our parsed specifiers into a frozen set and save them for later.
-        self._specs = frozenset(parsed)
-
-        # Store our prereleases value so we can use it later to determine if
-        # we accept prereleases or not.
-        self._prereleases = prereleases
-
-    def __repr__(self):
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
-        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
-
-    def __str__(self):
-        return ",".join(sorted(str(s) for s in self._specs))
-
-    def __hash__(self):
-        return hash(self._specs)
-
-    def __and__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        specifier = SpecifierSet()
-        specifier._specs = frozenset(self._specs | other._specs)
-
-        if self._prereleases is None and other._prereleases is not None:
-            specifier._prereleases = other._prereleases
-        elif self._prereleases is not None and other._prereleases is None:
-            specifier._prereleases = self._prereleases
-        elif self._prereleases == other._prereleases:
-            specifier._prereleases = self._prereleases
-        else:
-            raise ValueError(
-                "Cannot combine SpecifierSets with True and False prerelease "
-                "overrides."
-            )
-
-        return specifier
-
-    def __eq__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif isinstance(other, _IndividualSpecifier):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs == other._specs
-
-    def __ne__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif isinstance(other, _IndividualSpecifier):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs != other._specs
-
-    def __len__(self):
-        return len(self._specs)
-
-    def __iter__(self):
-        return iter(self._specs)
-
-    @property
-    def prereleases(self):
-        # If we have been given an explicit prerelease modifier, then we'll
-        # pass that through here.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # If we don't have any specifiers, and we don't have a forced value,
-        # then we'll just return None since we don't know if this should have
-        # pre-releases or not.
-        if not self._specs:
-            return None
-
-        # Otherwise we'll see if any of the given specifiers accept
-        # prereleases, if any of them do we'll return True, otherwise False.
-        return any(s.prereleases for s in self._specs)
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-    def __contains__(self, item):
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
-        # Ensure that our item is a Version or LegacyVersion instance.
-        if not isinstance(item, (LegacyVersion, Version)):
-            item = parse(item)
-
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # We can determine if we're going to allow pre-releases by looking to
-        # see if any of the underlying items supports them. If none of them do
-        # and this item is a pre-release then we do not allow it and we can
-        # short circuit that here.
-        # Note: This means that 1.0.dev1 would not be contained in something
-        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
-        if not prereleases and item.is_prerelease:
-            return False
-
-        # We simply dispatch to the underlying specs here to make sure that the
-        # given version is contained within all of them.
-        # Note: This use of all() here means that an empty set of specifiers
-        #       will always return True, this is an explicit design decision.
-        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
-
-    def filter(self, iterable, prereleases=None):
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # If we have any specifiers, then we want to wrap our iterable in the
-        # filter method for each one, this will act as a logical AND amongst
-        # each specifier.
-        if self._specs:
-            for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
-            return iterable
-        # If we do not have any specifiers, then we need to have a rough filter
-        # which will filter out any pre-releases, unless there are no final
-        # releases, and which will filter out LegacyVersion in general.
-        else:
-            filtered = []
-            found_prereleases = []
-
-            for item in iterable:
-                # Ensure that we some kind of Version class for this item.
-                if not isinstance(item, (LegacyVersion, Version)):
-                    parsed_version = parse(item)
-                else:
-                    parsed_version = item
-
-                # Filter out any item which is parsed as a LegacyVersion
-                if isinstance(parsed_version, LegacyVersion):
-                    continue
-
-                # Store any item which is a pre-release for later unless we've
-                # already found a final version or we are accepting prereleases
-                if parsed_version.is_prerelease and not prereleases:
-                    if not filtered:
-                        found_prereleases.append(item)
-                else:
-                    filtered.append(item)
-
-            # If we've found no items except for pre-releases, then we'll go
-            # ahead and use the pre-releases
-            if not filtered and found_prereleases and prereleases is None:
-                return found_prereleases
-
-            return filtered
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import abc 
+import functools 
+import itertools 
+import re 
+ 
+from ._compat import string_types, with_metaclass 
+from .version import Version, LegacyVersion, parse 
+ 
+ 
+class InvalidSpecifier(ValueError): 
+    """ 
+    An invalid specifier was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
+class BaseSpecifier(with_metaclass(abc.ABCMeta, object)): 
+    @abc.abstractmethod 
+    def __str__(self): 
+        """ 
+        Returns the str representation of this Specifier like object. This 
+        should be representative of the Specifier itself. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __hash__(self): 
+        """ 
+        Returns a hash value for this Specifier like object. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __eq__(self, other): 
+        """ 
+        Returns a boolean representing whether or not the two Specifier like 
+        objects are equal. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __ne__(self, other): 
+        """ 
+        Returns a boolean representing whether or not the two Specifier like 
+        objects are not equal. 
+        """ 
+ 
+    @abc.abstractproperty 
+    def prereleases(self): 
+        """ 
+        Returns whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        """ 
+        Sets whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def contains(self, item, prereleases=None): 
+        """ 
+        Determines if the given item is contained within this specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def filter(self, iterable, prereleases=None): 
+        """ 
+        Takes an iterable of items and filters them so that only items which 
+        are contained within this specifier are allowed in it. 
+        """ 
+ 
+ 
+class _IndividualSpecifier(BaseSpecifier): 
+ 
+    _operators = {} 
+ 
+    def __init__(self, spec="", prereleases=None): 
+        match = self._regex.search(spec) 
+        if not match: 
+            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec)) 
+ 
+        self._spec = (match.group("operator").strip(), match.group("version").strip()) 
+ 
+        # Store whether or not this Specifier should accept prereleases 
+        self._prereleases = prereleases 
+ 
+    def __repr__(self): 
+        pre = ( 
+            ", prereleases={0!r}".format(self.prereleases) 
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
+        return "<{0}({1!r}{2})>".format(self.__class__.__name__, str(self), pre) 
+ 
+    def __str__(self): 
+        return "{0}{1}".format(*self._spec) 
+ 
+    def __hash__(self): 
+        return hash(self._spec) 
+ 
+    def __eq__(self, other): 
+        if isinstance(other, string_types): 
+            try: 
+                other = self.__class__(other) 
+            except InvalidSpecifier: 
+                return NotImplemented 
+        elif not isinstance(other, self.__class__): 
+            return NotImplemented 
+ 
+        return self._spec == other._spec 
+ 
+    def __ne__(self, other): 
+        if isinstance(other, string_types): 
+            try: 
+                other = self.__class__(other) 
+            except InvalidSpecifier: 
+                return NotImplemented 
+        elif not isinstance(other, self.__class__): 
+            return NotImplemented 
+ 
+        return self._spec != other._spec 
+ 
+    def _get_operator(self, op): 
+        return getattr(self, "_compare_{0}".format(self._operators[op])) 
+ 
+    def _coerce_version(self, version): 
+        if not isinstance(version, (LegacyVersion, Version)): 
+            version = parse(version) 
+        return version 
+ 
+    @property 
+    def operator(self): 
+        return self._spec[0] 
+ 
+    @property 
+    def version(self): 
+        return self._spec[1] 
+ 
+    @property 
+    def prereleases(self): 
+        return self._prereleases 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        self._prereleases = value 
+ 
+    def __contains__(self, item): 
+        return self.contains(item) 
+ 
+    def contains(self, item, prereleases=None): 
+        # Determine if prereleases are to be allowed or not. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # Normalize item to a Version or LegacyVersion, this allows us to have 
+        # a shortcut for ``"2.0" in Specifier(">=2") 
+        item = self._coerce_version(item) 
+ 
+        # Determine if we should be supporting prereleases in this specifier 
+        # or not, if we do not support prereleases than we can short circuit 
+        # logic if this version is a prereleases. 
+        if item.is_prerelease and not prereleases: 
+            return False 
+ 
+        # Actually do the comparison to determine if this item is contained 
+        # within this Specifier or not. 
+        return self._get_operator(self.operator)(item, self.version) 
+ 
+    def filter(self, iterable, prereleases=None): 
+        yielded = False 
+        found_prereleases = [] 
+ 
+        kw = {"prereleases": prereleases if prereleases is not None else True} 
+ 
+        # Attempt to iterate over all the values in the iterable and if any of 
+        # them match, yield them. 
+        for version in iterable: 
+            parsed_version = self._coerce_version(version) 
+ 
+            if self.contains(parsed_version, **kw): 
+                # If our version is a prerelease, and we were not set to allow 
+                # prereleases, then we'll store it for later incase nothing 
+                # else matches this specifier. 
+                if parsed_version.is_prerelease and not ( 
+                    prereleases or self.prereleases 
+                ): 
+                    found_prereleases.append(version) 
+                # Either this is not a prerelease, or we should have been 
+                # accepting prereleases from the beginning. 
+                else: 
+                    yielded = True 
+                    yield version 
+ 
+        # Now that we've iterated over everything, determine if we've yielded 
+        # any values, and if we have not and we have any prereleases stored up 
+        # then we will go ahead and yield the prereleases. 
+        if not yielded and found_prereleases: 
+            for version in found_prereleases: 
+                yield version 
+ 
+ 
+class LegacySpecifier(_IndividualSpecifier): 
+ 
+    _regex_str = r""" 
+        (?P<operator>(==|!=|<=|>=|<|>)) 
+        \s* 
+        (?P<version> 
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version 
+                      # string can be just about anything, we match everything 
+                      # except for whitespace, a semi-colon for marker support, 
+                      # a closing paren since versions can be enclosed in 
+                      # them, and a comma since it's a version separator. 
+        ) 
+        """ 
+ 
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE) 
+ 
+    _operators = { 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+    } 
+ 
+    def _coerce_version(self, version): 
+        if not isinstance(version, LegacyVersion): 
+            version = LegacyVersion(str(version)) 
+        return version 
+ 
+    def _compare_equal(self, prospective, spec): 
+        return prospective == self._coerce_version(spec) 
+ 
+    def _compare_not_equal(self, prospective, spec): 
+        return prospective != self._coerce_version(spec) 
+ 
+    def _compare_less_than_equal(self, prospective, spec): 
+        return prospective <= self._coerce_version(spec) 
+ 
+    def _compare_greater_than_equal(self, prospective, spec): 
+        return prospective >= self._coerce_version(spec) 
+ 
+    def _compare_less_than(self, prospective, spec): 
+        return prospective < self._coerce_version(spec) 
+ 
+    def _compare_greater_than(self, prospective, spec): 
+        return prospective > self._coerce_version(spec) 
+ 
+ 
+def _require_version_compare(fn): 
+    @functools.wraps(fn) 
+    def wrapped(self, prospective, spec): 
+        if not isinstance(prospective, Version): 
+            return False 
+        return fn(self, prospective, spec) 
+ 
+    return wrapped 
+ 
+ 
+class Specifier(_IndividualSpecifier): 
+ 
+    _regex_str = r""" 
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===)) 
+        (?P<version> 
+            (?: 
+                # The identity operators allow for an escape hatch that will 
+                # do an exact string match of the version you wish to install. 
+                # This will not be parsed by PEP 440 and we cannot determine 
+                # any semantic meaning from it. This operator is discouraged 
+                # but included entirely as an escape hatch. 
+                (?<====)  # Only match for the identity operator 
+                \s* 
+                [^\s]*    # We just match everything, except for whitespace 
+                          # since we are only testing for strict identity. 
+            ) 
+            | 
+            (?: 
+                # The (non)equality operators allow for wild card and local 
+                # versions to be specified so we have to define these two 
+                # operators separately to enable that. 
+                (?<===|!=)            # Only match for equals and not equals 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+ 
+                # You cannot use a wild card and a dev or local version 
+                # together so group them with a | and make them optional. 
+                (?: 
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release 
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local 
+                    | 
+                    \.\*  # Wild card syntax of .* 
+                )? 
+            ) 
+            | 
+            (?: 
+                # The compatible operator requires at least two digits in the 
+                # release segment. 
+                (?<=~=)               # Only match for the compatible operator 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *) 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+            | 
+            (?: 
+                # All other operators only allow a sub set of what the 
+                # (non)equality operators do. Specifically they do not allow 
+                # local versions to be specified nor do they allow the prefix 
+                # matching wild cards. 
+                (?<!==|!=|~=)         # We have special cases for these 
+                                      # operators so we want to make sure they 
+                                      # don't match here. 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+        ) 
+        """ 
+ 
+    _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE) 
+ 
+    _operators = { 
+        "~=": "compatible", 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+        "===": "arbitrary", 
+    } 
+ 
+    @_require_version_compare 
+    def _compare_compatible(self, prospective, spec): 
+        # Compatible releases have an equivalent combination of >= and ==. That 
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to 
+        # implement this in terms of the other specifiers instead of 
+        # implementing it ourselves. The only thing we need to do is construct 
+        # the other specifiers. 
+ 
+        # We want everything but the last item in the version, but we want to 
+        # ignore post and dev releases and we want to treat the pre-release as 
+        # it's own separate segment. 
+        prefix = ".".join( 
+            list( 
+                itertools.takewhile( 
+                    lambda x: (not x.startswith("post") and not x.startswith("dev")), 
+                    _version_split(spec), 
+                ) 
+            )[:-1] 
+        ) 
+ 
+        # Add the prefix notation to the end of our string 
+        prefix += ".*" 
+ 
+        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( 
+            prospective, prefix 
+        ) 
+ 
+    @_require_version_compare 
+    def _compare_equal(self, prospective, spec): 
+        # We need special logic to handle prefix matching 
+        if spec.endswith(".*"): 
+            # In the case of prefix matching we want to ignore local segment. 
+            prospective = Version(prospective.public) 
+            # Split the spec out by dots, and pretend that there is an implicit 
+            # dot in between a release segment and a pre-release segment. 
+            spec = _version_split(spec[:-2])  # Remove the trailing .* 
+ 
+            # Split the prospective version out by dots, and pretend that there 
+            # is an implicit dot in between a release segment and a pre-release 
+            # segment. 
+            prospective = _version_split(str(prospective)) 
+ 
+            # Shorten the prospective version to be the same length as the spec 
+            # so that we can determine if the specifier is a prefix of the 
+            # prospective version or not. 
+            prospective = prospective[: len(spec)] 
+ 
+            # Pad out our two sides with zeros so that they both equal the same 
+            # length. 
+            spec, prospective = _pad_version(spec, prospective) 
+        else: 
+            # Convert our spec string into a Version 
+            spec = Version(spec) 
+ 
+            # If the specifier does not have a local segment, then we want to 
+            # act as if the prospective version also does not have a local 
+            # segment. 
+            if not spec.local: 
+                prospective = Version(prospective.public) 
+ 
+        return prospective == spec 
+ 
+    @_require_version_compare 
+    def _compare_not_equal(self, prospective, spec): 
+        return not self._compare_equal(prospective, spec) 
+ 
+    @_require_version_compare 
+    def _compare_less_than_equal(self, prospective, spec): 
+        return prospective <= Version(spec) 
+ 
+    @_require_version_compare 
+    def _compare_greater_than_equal(self, prospective, spec): 
+        return prospective >= Version(spec) 
+ 
+    @_require_version_compare 
+    def _compare_less_than(self, prospective, spec): 
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
+        spec = Version(spec) 
+ 
+        # Check to see if the prospective version is less than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective < spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a pre-release version, that we do not accept pre-release 
+        # versions for the version mentioned in the specifier (e.g. <3.1 should 
+        # not match 3.1.dev0, but should match 3.0.dev0). 
+        if not spec.is_prerelease and prospective.is_prerelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # less than the spec version *and* it's not a pre-release of the same 
+        # version in the spec. 
+        return True 
+ 
+    @_require_version_compare 
+    def _compare_greater_than(self, prospective, spec): 
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
+        spec = Version(spec) 
+ 
+        # Check to see if the prospective version is greater than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective > spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a post-release version, that we do not accept 
+        # post-release versions for the version mentioned in the specifier 
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). 
+        if not spec.is_postrelease and prospective.is_postrelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # Ensure that we do not allow a local version of the version mentioned 
+        # in the specifier, which is technically greater than, to match. 
+        if prospective.local is not None: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # greater than the spec version *and* it's not a pre-release of the 
+        # same version in the spec. 
+        return True 
+ 
+    def _compare_arbitrary(self, prospective, spec): 
+        return str(prospective).lower() == str(spec).lower() 
+ 
+    @property 
+    def prereleases(self): 
+        # If there is an explicit prereleases set for this, then we'll just 
+        # blindly use that. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # Look at all of our specifiers and determine if they are inclusive 
+        # operators, and if they are if they are including an explicit 
+        # prerelease. 
+        operator, version = self._spec 
+        if operator in ["==", ">=", "<=", "~=", "==="]: 
+            # The == specifier can include a trailing .*, if it does we 
+            # want to remove before parsing. 
+            if operator == "==" and version.endswith(".*"): 
+                version = version[:-2] 
+ 
+            # Parse the version, and if it is a pre-release than this 
+            # specifier allows pre-releases. 
+            if parse(version).is_prerelease: 
+                return True 
+ 
+        return False 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        self._prereleases = value 
+ 
+ 
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") 
+ 
+ 
+def _version_split(version): 
+    result = [] 
+    for item in version.split("."): 
+        match = _prefix_regex.search(item) 
+        if match: 
+            result.extend(match.groups()) 
+        else: 
+            result.append(item) 
+    return result 
+ 
+ 
+def _pad_version(left, right): 
+    left_split, right_split = [], [] 
+ 
+    # Get the release segment of our versions 
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) 
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) 
+ 
+    # Get the rest of our versions 
+    left_split.append(left[len(left_split[0]) :]) 
+    right_split.append(right[len(right_split[0]) :]) 
+ 
+    # Insert our padding 
+    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) 
+    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) 
+ 
+    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split))) 
+ 
+ 
+class SpecifierSet(BaseSpecifier): 
+    def __init__(self, specifiers="", prereleases=None): 
+        # Split on , to break each indidivual specifier into it's own item, and 
+        # strip each item to remove leading/trailing whitespace. 
+        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] 
+ 
+        # Parsed each individual specifier, attempting first to make it a 
+        # Specifier and falling back to a LegacySpecifier. 
+        parsed = set() 
+        for specifier in specifiers: 
+            try: 
+                parsed.add(Specifier(specifier)) 
+            except InvalidSpecifier: 
+                parsed.add(LegacySpecifier(specifier)) 
+ 
+        # Turn our parsed specifiers into a frozen set and save them for later. 
+        self._specs = frozenset(parsed) 
+ 
+        # Store our prereleases value so we can use it later to determine if 
+        # we accept prereleases or not. 
+        self._prereleases = prereleases 
+ 
+    def __repr__(self): 
+        pre = ( 
+            ", prereleases={0!r}".format(self.prereleases) 
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
+        return "<SpecifierSet({0!r}{1})>".format(str(self), pre) 
+ 
+    def __str__(self): 
+        return ",".join(sorted(str(s) for s in self._specs)) 
+ 
+    def __hash__(self): 
+        return hash(self._specs) 
+ 
+    def __and__(self, other): 
+        if isinstance(other, string_types): 
+            other = SpecifierSet(other) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        specifier = SpecifierSet() 
+        specifier._specs = frozenset(self._specs | other._specs) 
+ 
+        if self._prereleases is None and other._prereleases is not None: 
+            specifier._prereleases = other._prereleases 
+        elif self._prereleases is not None and other._prereleases is None: 
+            specifier._prereleases = self._prereleases 
+        elif self._prereleases == other._prereleases: 
+            specifier._prereleases = self._prereleases 
+        else: 
+            raise ValueError( 
+                "Cannot combine SpecifierSets with True and False prerelease " 
+                "overrides." 
+            ) 
+ 
+        return specifier 
+ 
+    def __eq__(self, other): 
+        if isinstance(other, string_types): 
+            other = SpecifierSet(other) 
+        elif isinstance(other, _IndividualSpecifier): 
+            other = SpecifierSet(str(other)) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        return self._specs == other._specs 
+ 
+    def __ne__(self, other): 
+        if isinstance(other, string_types): 
+            other = SpecifierSet(other) 
+        elif isinstance(other, _IndividualSpecifier): 
+            other = SpecifierSet(str(other)) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        return self._specs != other._specs 
+ 
+    def __len__(self): 
+        return len(self._specs) 
+ 
+    def __iter__(self): 
+        return iter(self._specs) 
+ 
+    @property 
+    def prereleases(self): 
+        # If we have been given an explicit prerelease modifier, then we'll 
+        # pass that through here. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # If we don't have any specifiers, and we don't have a forced value, 
+        # then we'll just return None since we don't know if this should have 
+        # pre-releases or not. 
+        if not self._specs: 
+            return None 
+ 
+        # Otherwise we'll see if any of the given specifiers accept 
+        # prereleases, if any of them do we'll return True, otherwise False. 
+        return any(s.prereleases for s in self._specs) 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
+        self._prereleases = value 
+ 
+    def __contains__(self, item): 
+        return self.contains(item) 
+ 
+    def contains(self, item, prereleases=None): 
+        # Ensure that our item is a Version or LegacyVersion instance. 
+        if not isinstance(item, (LegacyVersion, Version)): 
+            item = parse(item) 
+ 
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # We can determine if we're going to allow pre-releases by looking to 
+        # see if any of the underlying items supports them. If none of them do 
+        # and this item is a pre-release then we do not allow it and we can 
+        # short circuit that here. 
+        # Note: This means that 1.0.dev1 would not be contained in something 
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 
+        if not prereleases and item.is_prerelease: 
+            return False 
+ 
+        # We simply dispatch to the underlying specs here to make sure that the 
+        # given version is contained within all of them. 
+        # Note: This use of all() here means that an empty set of specifiers 
+        #       will always return True, this is an explicit design decision. 
+        return all(s.contains(item, prereleases=prereleases) for s in self._specs) 
+ 
+    def filter(self, iterable, prereleases=None): 
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # If we have any specifiers, then we want to wrap our iterable in the 
+        # filter method for each one, this will act as a logical AND amongst 
+        # each specifier. 
+        if self._specs: 
+            for spec in self._specs: 
+                iterable = spec.filter(iterable, prereleases=bool(prereleases)) 
+            return iterable 
+        # If we do not have any specifiers, then we need to have a rough filter 
+        # which will filter out any pre-releases, unless there are no final 
+        # releases, and which will filter out LegacyVersion in general. 
+        else: 
+            filtered = [] 
+            found_prereleases = [] 
+ 
+            for item in iterable: 
+                # Ensure that we some kind of Version class for this item. 
+                if not isinstance(item, (LegacyVersion, Version)): 
+                    parsed_version = parse(item) 
+                else: 
+                    parsed_version = item 
+ 
+                # Filter out any item which is parsed as a LegacyVersion 
+                if isinstance(parsed_version, LegacyVersion): 
+                    continue 
+ 
+                # Store any item which is a pre-release for later unless we've 
+                # already found a final version or we are accepting prereleases 
+                if parsed_version.is_prerelease and not prereleases: 
+                    if not filtered: 
+                        found_prereleases.append(item) 
+                else: 
+                    filtered.append(item) 
+ 
+            # If we've found no items except for pre-releases, then we'll go 
+            # ahead and use the pre-releases 
+            if not filtered and found_prereleases and prereleases is None: 
+                return found_prereleases 
+ 
+            return filtered 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/tags.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/tags.py
index ec9942f0f6..a982a22461 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/tags.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/tags.py
@@ -1,404 +1,404 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-from __future__ import absolute_import
-
-import distutils.util
-
-try:
-    from importlib.machinery import EXTENSION_SUFFIXES
-except ImportError:  # pragma: no cover
-    import imp
-
-    EXTENSION_SUFFIXES = [x[0] for x in imp.get_suffixes()]
-    del imp
-import platform
-import re
-import sys
-import sysconfig
-import warnings
-
-
-INTERPRETER_SHORT_NAMES = {
-    "python": "py",  # Generic.
-    "cpython": "cp",
-    "pypy": "pp",
-    "ironpython": "ip",
-    "jython": "jy",
-}
-
-
-_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
-
-
-class Tag(object):
-
-    __slots__ = ["_interpreter", "_abi", "_platform"]
-
-    def __init__(self, interpreter, abi, platform):
-        self._interpreter = interpreter.lower()
-        self._abi = abi.lower()
-        self._platform = platform.lower()
-
-    @property
-    def interpreter(self):
-        return self._interpreter
-
-    @property
-    def abi(self):
-        return self._abi
-
-    @property
-    def platform(self):
-        return self._platform
-
-    def __eq__(self, other):
-        return (
-            (self.platform == other.platform)
-            and (self.abi == other.abi)
-            and (self.interpreter == other.interpreter)
-        )
-
-    def __hash__(self):
-        return hash((self._interpreter, self._abi, self._platform))
-
-    def __str__(self):
-        return "{}-{}-{}".format(self._interpreter, self._abi, self._platform)
-
-    def __repr__(self):
-        return "<{self} @ {self_id}>".format(self=self, self_id=id(self))
-
-
-def parse_tag(tag):
-    tags = set()
-    interpreters, abis, platforms = tag.split("-")
-    for interpreter in interpreters.split("."):
-        for abi in abis.split("."):
-            for platform_ in platforms.split("."):
-                tags.add(Tag(interpreter, abi, platform_))
-    return frozenset(tags)
-
-
-def _normalize_string(string):
-    return string.replace(".", "_").replace("-", "_")
-
-
-def _cpython_interpreter(py_version):
-    # TODO: Is using py_version_nodot for interpreter version critical?
-    return "cp{major}{minor}".format(major=py_version[0], minor=py_version[1])
-
-
-def _cpython_abis(py_version):
-    abis = []
-    version = "{}{}".format(*py_version[:2])
-    debug = pymalloc = ucs4 = ""
-    with_debug = sysconfig.get_config_var("Py_DEBUG")
-    has_refcount = hasattr(sys, "gettotalrefcount")
-    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
-    # extension modules is the best option.
-    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
-    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
-    if with_debug or (with_debug is None and (has_refcount or has_ext)):
-        debug = "d"
-    if py_version < (3, 8):
-        with_pymalloc = sysconfig.get_config_var("WITH_PYMALLOC")
-        if with_pymalloc or with_pymalloc is None:
-            pymalloc = "m"
-        if py_version < (3, 3):
-            unicode_size = sysconfig.get_config_var("Py_UNICODE_SIZE")
-            if unicode_size == 4 or (
-                unicode_size is None and sys.maxunicode == 0x10FFFF
-            ):
-                ucs4 = "u"
-    elif debug:
-        # Debug builds can also load "normal" extension modules.
-        # We can also assume no UCS-4 or pymalloc requirement.
-        abis.append("cp{version}".format(version=version))
-    abis.insert(
-        0,
-        "cp{version}{debug}{pymalloc}{ucs4}".format(
-            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
-        ),
-    )
-    return abis
-
-
-def _cpython_tags(py_version, interpreter, abis, platforms):
-    for abi in abis:
-        for platform_ in platforms:
-            yield Tag(interpreter, abi, platform_)
-    for tag in (Tag(interpreter, "abi3", platform_) for platform_ in platforms):
-        yield tag
-    for tag in (Tag(interpreter, "none", platform_) for platform_ in platforms):
-        yield tag
-    # PEP 384 was first implemented in Python 3.2.
-    for minor_version in range(py_version[1] - 1, 1, -1):
-        for platform_ in platforms:
-            interpreter = "cp{major}{minor}".format(
-                major=py_version[0], minor=minor_version
-            )
-            yield Tag(interpreter, "abi3", platform_)
-
-
-def _pypy_interpreter():
-    return "pp{py_major}{pypy_major}{pypy_minor}".format(
-        py_major=sys.version_info[0],
-        pypy_major=sys.pypy_version_info.major,
-        pypy_minor=sys.pypy_version_info.minor,
-    )
-
-
-def _generic_abi():
-    abi = sysconfig.get_config_var("SOABI")
-    if abi:
-        return _normalize_string(abi)
-    else:
-        return "none"
-
-
-def _pypy_tags(py_version, interpreter, abi, platforms):
-    for tag in (Tag(interpreter, abi, platform) for platform in platforms):
-        yield tag
-    for tag in (Tag(interpreter, "none", platform) for platform in platforms):
-        yield tag
-
-
-def _generic_tags(interpreter, py_version, abi, platforms):
-    for tag in (Tag(interpreter, abi, platform) for platform in platforms):
-        yield tag
-    if abi != "none":
-        tags = (Tag(interpreter, "none", platform_) for platform_ in platforms)
-        for tag in tags:
-            yield tag
-
-
-def _py_interpreter_range(py_version):
-    """
-    Yield Python versions in descending order.
-
-    After the latest version, the major-only version will be yielded, and then
-    all following versions up to 'end'.
-    """
-    yield "py{major}{minor}".format(major=py_version[0], minor=py_version[1])
-    yield "py{major}".format(major=py_version[0])
-    for minor in range(py_version[1] - 1, -1, -1):
-        yield "py{major}{minor}".format(major=py_version[0], minor=minor)
-
-
-def _independent_tags(interpreter, py_version, platforms):
-    """
-    Return the sequence of tags that are consistent across implementations.
-
-    The tags consist of:
-    - py*-none-<platform>
-    - <interpreter>-none-any
-    - py*-none-any
-    """
-    for version in _py_interpreter_range(py_version):
-        for platform_ in platforms:
-            yield Tag(version, "none", platform_)
-    yield Tag(interpreter, "none", "any")
-    for version in _py_interpreter_range(py_version):
-        yield Tag(version, "none", "any")
-
-
-def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER):
-    if not is_32bit:
-        return arch
-
-    if arch.startswith("ppc"):
-        return "ppc"
-
-    return "i386"
-
-
-def _mac_binary_formats(version, cpu_arch):
-    formats = [cpu_arch]
-    if cpu_arch == "x86_64":
-        if version < (10, 4):
-            return []
-        formats.extend(["intel", "fat64", "fat32"])
-
-    elif cpu_arch == "i386":
-        if version < (10, 4):
-            return []
-        formats.extend(["intel", "fat32", "fat"])
-
-    elif cpu_arch == "ppc64":
-        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
-        if version > (10, 5) or version < (10, 4):
-            return []
-        formats.append("fat64")
-
-    elif cpu_arch == "ppc":
-        if version > (10, 6):
-            return []
-        formats.extend(["fat32", "fat"])
-
-    formats.append("universal")
-    return formats
-
-
-def _mac_platforms(version=None, arch=None):
-    version_str, _, cpu_arch = platform.mac_ver()
-    if version is None:
-        version = tuple(map(int, version_str.split(".")[:2]))
-    if arch is None:
-        arch = _mac_arch(cpu_arch)
-    platforms = []
-    for minor_version in range(version[1], -1, -1):
-        compat_version = version[0], minor_version
-        binary_formats = _mac_binary_formats(compat_version, arch)
-        for binary_format in binary_formats:
-            platforms.append(
-                "macosx_{major}_{minor}_{binary_format}".format(
-                    major=compat_version[0],
-                    minor=compat_version[1],
-                    binary_format=binary_format,
-                )
-            )
-    return platforms
-
-
-# From PEP 513.
-def _is_manylinux_compatible(name, glibc_version):
-    # Check for presence of _manylinux module.
-    try:
-        import _manylinux
-
-        return bool(getattr(_manylinux, name + "_compatible"))
-    except (ImportError, AttributeError):
-        # Fall through to heuristic check below.
-        pass
-
-    return _have_compatible_glibc(*glibc_version)
-
-
-def _glibc_version_string():
-    # Returns glibc version string, or None if not using glibc.
-    import ctypes
-
-    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
-    # manpage says, "If filename is NULL, then the returned handle is for the
-    # main program". This way we can let the linker do the work to figure out
-    # which libc our process is actually using.
-    process_namespace = ctypes.CDLL(None)
-    try:
-        gnu_get_libc_version = process_namespace.gnu_get_libc_version
-    except AttributeError:
-        # Symbol doesn't exist -> therefore, we are not linked to
-        # glibc.
-        return None
-
-    # Call gnu_get_libc_version, which returns a string like "2.5"
-    gnu_get_libc_version.restype = ctypes.c_char_p
-    version_str = gnu_get_libc_version()
-    # py2 / py3 compatibility:
-    if not isinstance(version_str, str):
-        version_str = version_str.decode("ascii")
-
-    return version_str
-
-
-# Separated out from have_compatible_glibc for easier unit testing.
-def _check_glibc_version(version_str, required_major, minimum_minor):
-    # Parse string and check against requested version.
-    #
-    # We use a regexp instead of str.split because we want to discard any
-    # random junk that might come after the minor version -- this might happen
-    # in patched/forked versions of glibc (e.g. Linaro's version of glibc
-    # uses version strings like "2.20-2014.11"). See gh-3588.
-    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
-    if not m:
-        warnings.warn(
-            "Expected glibc version with 2 components major.minor,"
-            " got: %s" % version_str,
-            RuntimeWarning,
-        )
-        return False
-    return (
-        int(m.group("major")) == required_major
-        and int(m.group("minor")) >= minimum_minor
-    )
-
-
-def _have_compatible_glibc(required_major, minimum_minor):
-    version_str = _glibc_version_string()
-    if version_str is None:
-        return False
-    return _check_glibc_version(version_str, required_major, minimum_minor)
-
-
-def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):
-    linux = _normalize_string(distutils.util.get_platform())
-    if linux == "linux_x86_64" and is_32bit:
-        linux = "linux_i686"
-    manylinux_support = (
-        ("manylinux2014", (2, 17)),  # CentOS 7 w/ glibc 2.17 (PEP 599)
-        ("manylinux2010", (2, 12)),  # CentOS 6 w/ glibc 2.12 (PEP 571)
-        ("manylinux1", (2, 5)),  # CentOS 5 w/ glibc 2.5 (PEP 513)
-    )
-    manylinux_support_iter = iter(manylinux_support)
-    for name, glibc_version in manylinux_support_iter:
-        if _is_manylinux_compatible(name, glibc_version):
-            platforms = [linux.replace("linux", name)]
-            break
-    else:
-        platforms = []
-    # Support for a later manylinux implies support for an earlier version.
-    platforms += [linux.replace("linux", name) for name, _ in manylinux_support_iter]
-    platforms.append(linux)
-    return platforms
-
-
-def _generic_platforms():
-    platform = _normalize_string(distutils.util.get_platform())
-    return [platform]
-
-
-def _interpreter_name():
-    name = platform.python_implementation().lower()
-    return INTERPRETER_SHORT_NAMES.get(name) or name
-
-
-def _generic_interpreter(name, py_version):
-    version = sysconfig.get_config_var("py_version_nodot")
-    if not version:
-        version = "".join(map(str, py_version[:2]))
-    return "{name}{version}".format(name=name, version=version)
-
-
-def sys_tags():
-    """
-    Returns the sequence of tag triples for the running interpreter.
-
-    The order of the sequence corresponds to priority order for the
-    interpreter, from most to least important.
-    """
-    py_version = sys.version_info[:2]
-    interpreter_name = _interpreter_name()
-    if platform.system() == "Darwin":
-        platforms = _mac_platforms()
-    elif platform.system() == "Linux":
-        platforms = _linux_platforms()
-    else:
-        platforms = _generic_platforms()
-
-    if interpreter_name == "cp":
-        interpreter = _cpython_interpreter(py_version)
-        abis = _cpython_abis(py_version)
-        for tag in _cpython_tags(py_version, interpreter, abis, platforms):
-            yield tag
-    elif interpreter_name == "pp":
-        interpreter = _pypy_interpreter()
-        abi = _generic_abi()
-        for tag in _pypy_tags(py_version, interpreter, abi, platforms):
-            yield tag
-    else:
-        interpreter = _generic_interpreter(interpreter_name, py_version)
-        abi = _generic_abi()
-        for tag in _generic_tags(interpreter, py_version, abi, platforms):
-            yield tag
-    for tag in _independent_tags(interpreter, py_version, platforms):
-        yield tag
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+ 
+from __future__ import absolute_import 
+ 
+import distutils.util 
+ 
+try: 
+    from importlib.machinery import EXTENSION_SUFFIXES 
+except ImportError:  # pragma: no cover 
+    import imp 
+ 
+    EXTENSION_SUFFIXES = [x[0] for x in imp.get_suffixes()] 
+    del imp 
+import platform 
+import re 
+import sys 
+import sysconfig 
+import warnings 
+ 
+ 
+INTERPRETER_SHORT_NAMES = { 
+    "python": "py",  # Generic. 
+    "cpython": "cp", 
+    "pypy": "pp", 
+    "ironpython": "ip", 
+    "jython": "jy", 
+} 
+ 
+ 
+_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32 
+ 
+ 
+class Tag(object): 
+ 
+    __slots__ = ["_interpreter", "_abi", "_platform"] 
+ 
+    def __init__(self, interpreter, abi, platform): 
+        self._interpreter = interpreter.lower() 
+        self._abi = abi.lower() 
+        self._platform = platform.lower() 
+ 
+    @property 
+    def interpreter(self): 
+        return self._interpreter 
+ 
+    @property 
+    def abi(self): 
+        return self._abi 
+ 
+    @property 
+    def platform(self): 
+        return self._platform 
+ 
+    def __eq__(self, other): 
+        return ( 
+            (self.platform == other.platform) 
+            and (self.abi == other.abi) 
+            and (self.interpreter == other.interpreter) 
+        ) 
+ 
+    def __hash__(self): 
+        return hash((self._interpreter, self._abi, self._platform)) 
+ 
+    def __str__(self): 
+        return "{}-{}-{}".format(self._interpreter, self._abi, self._platform) 
+ 
+    def __repr__(self): 
+        return "<{self} @ {self_id}>".format(self=self, self_id=id(self)) 
+ 
+ 
+def parse_tag(tag): 
+    tags = set() 
+    interpreters, abis, platforms = tag.split("-") 
+    for interpreter in interpreters.split("."): 
+        for abi in abis.split("."): 
+            for platform_ in platforms.split("."): 
+                tags.add(Tag(interpreter, abi, platform_)) 
+    return frozenset(tags) 
+ 
+ 
+def _normalize_string(string): 
+    return string.replace(".", "_").replace("-", "_") 
+ 
+ 
+def _cpython_interpreter(py_version): 
+    # TODO: Is using py_version_nodot for interpreter version critical? 
+    return "cp{major}{minor}".format(major=py_version[0], minor=py_version[1]) 
+ 
+ 
+def _cpython_abis(py_version): 
+    abis = [] 
+    version = "{}{}".format(*py_version[:2]) 
+    debug = pymalloc = ucs4 = "" 
+    with_debug = sysconfig.get_config_var("Py_DEBUG") 
+    has_refcount = hasattr(sys, "gettotalrefcount") 
+    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled 
+    # extension modules is the best option. 
+    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 
+    has_ext = "_d.pyd" in EXTENSION_SUFFIXES 
+    if with_debug or (with_debug is None and (has_refcount or has_ext)): 
+        debug = "d" 
+    if py_version < (3, 8): 
+        with_pymalloc = sysconfig.get_config_var("WITH_PYMALLOC") 
+        if with_pymalloc or with_pymalloc is None: 
+            pymalloc = "m" 
+        if py_version < (3, 3): 
+            unicode_size = sysconfig.get_config_var("Py_UNICODE_SIZE") 
+            if unicode_size == 4 or ( 
+                unicode_size is None and sys.maxunicode == 0x10FFFF 
+            ): 
+                ucs4 = "u" 
+    elif debug: 
+        # Debug builds can also load "normal" extension modules. 
+        # We can also assume no UCS-4 or pymalloc requirement. 
+        abis.append("cp{version}".format(version=version)) 
+    abis.insert( 
+        0, 
+        "cp{version}{debug}{pymalloc}{ucs4}".format( 
+            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4 
+        ), 
+    ) 
+    return abis 
+ 
+ 
+def _cpython_tags(py_version, interpreter, abis, platforms): 
+    for abi in abis: 
+        for platform_ in platforms: 
+            yield Tag(interpreter, abi, platform_) 
+    for tag in (Tag(interpreter, "abi3", platform_) for platform_ in platforms): 
+        yield tag 
+    for tag in (Tag(interpreter, "none", platform_) for platform_ in platforms): 
+        yield tag 
+    # PEP 384 was first implemented in Python 3.2. 
+    for minor_version in range(py_version[1] - 1, 1, -1): 
+        for platform_ in platforms: 
+            interpreter = "cp{major}{minor}".format( 
+                major=py_version[0], minor=minor_version 
+            ) 
+            yield Tag(interpreter, "abi3", platform_) 
+ 
+ 
+def _pypy_interpreter(): 
+    return "pp{py_major}{pypy_major}{pypy_minor}".format( 
+        py_major=sys.version_info[0], 
+        pypy_major=sys.pypy_version_info.major, 
+        pypy_minor=sys.pypy_version_info.minor, 
+    ) 
+ 
+ 
+def _generic_abi(): 
+    abi = sysconfig.get_config_var("SOABI") 
+    if abi: 
+        return _normalize_string(abi) 
+    else: 
+        return "none" 
+ 
+ 
+def _pypy_tags(py_version, interpreter, abi, platforms): 
+    for tag in (Tag(interpreter, abi, platform) for platform in platforms): 
+        yield tag 
+    for tag in (Tag(interpreter, "none", platform) for platform in platforms): 
+        yield tag 
+ 
+ 
+def _generic_tags(interpreter, py_version, abi, platforms): 
+    for tag in (Tag(interpreter, abi, platform) for platform in platforms): 
+        yield tag 
+    if abi != "none": 
+        tags = (Tag(interpreter, "none", platform_) for platform_ in platforms) 
+        for tag in tags: 
+            yield tag 
+ 
+ 
+def _py_interpreter_range(py_version): 
+    """ 
+    Yield Python versions in descending order. 
+ 
+    After the latest version, the major-only version will be yielded, and then 
+    all following versions up to 'end'. 
+    """ 
+    yield "py{major}{minor}".format(major=py_version[0], minor=py_version[1]) 
+    yield "py{major}".format(major=py_version[0]) 
+    for minor in range(py_version[1] - 1, -1, -1): 
+        yield "py{major}{minor}".format(major=py_version[0], minor=minor) 
+ 
+ 
+def _independent_tags(interpreter, py_version, platforms): 
+    """ 
+    Return the sequence of tags that are consistent across implementations. 
+ 
+    The tags consist of: 
+    - py*-none-<platform> 
+    - <interpreter>-none-any 
+    - py*-none-any 
+    """ 
+    for version in _py_interpreter_range(py_version): 
+        for platform_ in platforms: 
+            yield Tag(version, "none", platform_) 
+    yield Tag(interpreter, "none", "any") 
+    for version in _py_interpreter_range(py_version): 
+        yield Tag(version, "none", "any") 
+ 
+ 
+def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER): 
+    if not is_32bit: 
+        return arch 
+ 
+    if arch.startswith("ppc"): 
+        return "ppc" 
+ 
+    return "i386" 
+ 
+ 
+def _mac_binary_formats(version, cpu_arch): 
+    formats = [cpu_arch] 
+    if cpu_arch == "x86_64": 
+        if version < (10, 4): 
+            return [] 
+        formats.extend(["intel", "fat64", "fat32"]) 
+ 
+    elif cpu_arch == "i386": 
+        if version < (10, 4): 
+            return [] 
+        formats.extend(["intel", "fat32", "fat"]) 
+ 
+    elif cpu_arch == "ppc64": 
+        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? 
+        if version > (10, 5) or version < (10, 4): 
+            return [] 
+        formats.append("fat64") 
+ 
+    elif cpu_arch == "ppc": 
+        if version > (10, 6): 
+            return [] 
+        formats.extend(["fat32", "fat"]) 
+ 
+    formats.append("universal") 
+    return formats 
+ 
+ 
+def _mac_platforms(version=None, arch=None): 
+    version_str, _, cpu_arch = platform.mac_ver() 
+    if version is None: 
+        version = tuple(map(int, version_str.split(".")[:2])) 
+    if arch is None: 
+        arch = _mac_arch(cpu_arch) 
+    platforms = [] 
+    for minor_version in range(version[1], -1, -1): 
+        compat_version = version[0], minor_version 
+        binary_formats = _mac_binary_formats(compat_version, arch) 
+        for binary_format in binary_formats: 
+            platforms.append( 
+                "macosx_{major}_{minor}_{binary_format}".format( 
+                    major=compat_version[0], 
+                    minor=compat_version[1], 
+                    binary_format=binary_format, 
+                ) 
+            ) 
+    return platforms 
+ 
+ 
+# From PEP 513. 
+def _is_manylinux_compatible(name, glibc_version): 
+    # Check for presence of _manylinux module. 
+    try: 
+        import _manylinux 
+ 
+        return bool(getattr(_manylinux, name + "_compatible")) 
+    except (ImportError, AttributeError): 
+        # Fall through to heuristic check below. 
+        pass 
+ 
+    return _have_compatible_glibc(*glibc_version) 
+ 
+ 
+def _glibc_version_string(): 
+    # Returns glibc version string, or None if not using glibc. 
+    import ctypes 
+ 
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen 
+    # manpage says, "If filename is NULL, then the returned handle is for the 
+    # main program". This way we can let the linker do the work to figure out 
+    # which libc our process is actually using. 
+    process_namespace = ctypes.CDLL(None) 
+    try: 
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version 
+    except AttributeError: 
+        # Symbol doesn't exist -> therefore, we are not linked to 
+        # glibc. 
+        return None 
+ 
+    # Call gnu_get_libc_version, which returns a string like "2.5" 
+    gnu_get_libc_version.restype = ctypes.c_char_p 
+    version_str = gnu_get_libc_version() 
+    # py2 / py3 compatibility: 
+    if not isinstance(version_str, str): 
+        version_str = version_str.decode("ascii") 
+ 
+    return version_str 
+ 
+ 
+# Separated out from have_compatible_glibc for easier unit testing. 
+def _check_glibc_version(version_str, required_major, minimum_minor): 
+    # Parse string and check against requested version. 
+    # 
+    # We use a regexp instead of str.split because we want to discard any 
+    # random junk that might come after the minor version -- this might happen 
+    # in patched/forked versions of glibc (e.g. Linaro's version of glibc 
+    # uses version strings like "2.20-2014.11"). See gh-3588. 
+    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str) 
+    if not m: 
+        warnings.warn( 
+            "Expected glibc version with 2 components major.minor," 
+            " got: %s" % version_str, 
+            RuntimeWarning, 
+        ) 
+        return False 
+    return ( 
+        int(m.group("major")) == required_major 
+        and int(m.group("minor")) >= minimum_minor 
+    ) 
+ 
+ 
+def _have_compatible_glibc(required_major, minimum_minor): 
+    version_str = _glibc_version_string() 
+    if version_str is None: 
+        return False 
+    return _check_glibc_version(version_str, required_major, minimum_minor) 
+ 
+ 
+def _linux_platforms(is_32bit=_32_BIT_INTERPRETER): 
+    linux = _normalize_string(distutils.util.get_platform()) 
+    if linux == "linux_x86_64" and is_32bit: 
+        linux = "linux_i686" 
+    manylinux_support = ( 
+        ("manylinux2014", (2, 17)),  # CentOS 7 w/ glibc 2.17 (PEP 599) 
+        ("manylinux2010", (2, 12)),  # CentOS 6 w/ glibc 2.12 (PEP 571) 
+        ("manylinux1", (2, 5)),  # CentOS 5 w/ glibc 2.5 (PEP 513) 
+    ) 
+    manylinux_support_iter = iter(manylinux_support) 
+    for name, glibc_version in manylinux_support_iter: 
+        if _is_manylinux_compatible(name, glibc_version): 
+            platforms = [linux.replace("linux", name)] 
+            break 
+    else: 
+        platforms = [] 
+    # Support for a later manylinux implies support for an earlier version. 
+    platforms += [linux.replace("linux", name) for name, _ in manylinux_support_iter] 
+    platforms.append(linux) 
+    return platforms 
+ 
+ 
+def _generic_platforms(): 
+    platform = _normalize_string(distutils.util.get_platform()) 
+    return [platform] 
+ 
+ 
+def _interpreter_name(): 
+    name = platform.python_implementation().lower() 
+    return INTERPRETER_SHORT_NAMES.get(name) or name 
+ 
+ 
+def _generic_interpreter(name, py_version): 
+    version = sysconfig.get_config_var("py_version_nodot") 
+    if not version: 
+        version = "".join(map(str, py_version[:2])) 
+    return "{name}{version}".format(name=name, version=version) 
+ 
+ 
+def sys_tags(): 
+    """ 
+    Returns the sequence of tag triples for the running interpreter. 
+ 
+    The order of the sequence corresponds to priority order for the 
+    interpreter, from most to least important. 
+    """ 
+    py_version = sys.version_info[:2] 
+    interpreter_name = _interpreter_name() 
+    if platform.system() == "Darwin": 
+        platforms = _mac_platforms() 
+    elif platform.system() == "Linux": 
+        platforms = _linux_platforms() 
+    else: 
+        platforms = _generic_platforms() 
+ 
+    if interpreter_name == "cp": 
+        interpreter = _cpython_interpreter(py_version) 
+        abis = _cpython_abis(py_version) 
+        for tag in _cpython_tags(py_version, interpreter, abis, platforms): 
+            yield tag 
+    elif interpreter_name == "pp": 
+        interpreter = _pypy_interpreter() 
+        abi = _generic_abi() 
+        for tag in _pypy_tags(py_version, interpreter, abi, platforms): 
+            yield tag 
+    else: 
+        interpreter = _generic_interpreter(interpreter_name, py_version) 
+        abi = _generic_abi() 
+        for tag in _generic_tags(interpreter, py_version, abi, platforms): 
+            yield tag 
+    for tag in _independent_tags(interpreter, py_version, platforms): 
+        yield tag 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/utils.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/utils.py
index 8841878693..7f4b515b7c 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/utils.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/utils.py
@@ -1,57 +1,57 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import re
-
-from .version import InvalidVersion, Version
-
-
-_canonicalize_regex = re.compile(r"[-_.]+")
-
-
-def canonicalize_name(name):
-    # This is taken from PEP 503.
-    return _canonicalize_regex.sub("-", name).lower()
-
-
-def canonicalize_version(version):
-    """
-    This is very similar to Version.__str__, but has one subtle differences
-    with the way it handles the release segment.
-    """
-
-    try:
-        version = Version(version)
-    except InvalidVersion:
-        # Legacy versions cannot be normalized
-        return version
-
-    parts = []
-
-    # Epoch
-    if version.epoch != 0:
-        parts.append("{0}!".format(version.epoch))
-
-    # Release segment
-    # NB: This strips trailing '.0's to normalize
-    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release)))
-
-    # Pre-release
-    if version.pre is not None:
-        parts.append("".join(str(x) for x in version.pre))
-
-    # Post-release
-    if version.post is not None:
-        parts.append(".post{0}".format(version.post))
-
-    # Development release
-    if version.dev is not None:
-        parts.append(".dev{0}".format(version.dev))
-
-    # Local version segment
-    if version.local is not None:
-        parts.append("+{0}".format(version.local))
-
-    return "".join(parts)
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import re 
+ 
+from .version import InvalidVersion, Version 
+ 
+ 
+_canonicalize_regex = re.compile(r"[-_.]+") 
+ 
+ 
+def canonicalize_name(name): 
+    # This is taken from PEP 503. 
+    return _canonicalize_regex.sub("-", name).lower() 
+ 
+ 
+def canonicalize_version(version): 
+    """ 
+    This is very similar to Version.__str__, but has one subtle differences 
+    with the way it handles the release segment. 
+    """ 
+ 
+    try: 
+        version = Version(version) 
+    except InvalidVersion: 
+        # Legacy versions cannot be normalized 
+        return version 
+ 
+    parts = [] 
+ 
+    # Epoch 
+    if version.epoch != 0: 
+        parts.append("{0}!".format(version.epoch)) 
+ 
+    # Release segment 
+    # NB: This strips trailing '.0's to normalize 
+    parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release))) 
+ 
+    # Pre-release 
+    if version.pre is not None: 
+        parts.append("".join(str(x) for x in version.pre)) 
+ 
+    # Post-release 
+    if version.post is not None: 
+        parts.append(".post{0}".format(version.post)) 
+ 
+    # Development release 
+    if version.dev is not None: 
+        parts.append(".dev{0}".format(version.dev)) 
+ 
+    # Local version segment 
+    if version.local is not None: 
+        parts.append("+{0}".format(version.local)) 
+ 
+    return "".join(parts) 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/version.py b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/version.py
index 95157a1f78..694191c525 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/packaging/version.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/packaging/version.py
@@ -1,420 +1,420 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import collections
-import itertools
-import re
-
-from ._structures import Infinity
-
-
-__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
-
-
-_Version = collections.namedtuple(
-    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
-)
-
-
-def parse(version):
-    """
-    Parse the given version string and return either a :class:`Version` object
-    or a :class:`LegacyVersion` object depending on if the given version is
-    a valid PEP 440 version or a legacy version.
-    """
-    try:
-        return Version(version)
-    except InvalidVersion:
-        return LegacyVersion(version)
-
-
-class InvalidVersion(ValueError):
-    """
-    An invalid version was found, users should refer to PEP 440.
-    """
-
-
-class _BaseVersion(object):
-    def __hash__(self):
-        return hash(self._key)
-
-    def __lt__(self, other):
-        return self._compare(other, lambda s, o: s < o)
-
-    def __le__(self, other):
-        return self._compare(other, lambda s, o: s <= o)
-
-    def __eq__(self, other):
-        return self._compare(other, lambda s, o: s == o)
-
-    def __ge__(self, other):
-        return self._compare(other, lambda s, o: s >= o)
-
-    def __gt__(self, other):
-        return self._compare(other, lambda s, o: s > o)
-
-    def __ne__(self, other):
-        return self._compare(other, lambda s, o: s != o)
-
-    def _compare(self, other, method):
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return method(self._key, other._key)
-
-
-class LegacyVersion(_BaseVersion):
-    def __init__(self, version):
-        self._version = str(version)
-        self._key = _legacy_cmpkey(self._version)
-
-    def __str__(self):
-        return self._version
-
-    def __repr__(self):
-        return "<LegacyVersion({0})>".format(repr(str(self)))
-
-    @property
-    def public(self):
-        return self._version
-
-    @property
-    def base_version(self):
-        return self._version
-
-    @property
-    def epoch(self):
-        return -1
-
-    @property
-    def release(self):
-        return None
-
-    @property
-    def pre(self):
-        return None
-
-    @property
-    def post(self):
-        return None
-
-    @property
-    def dev(self):
-        return None
-
-    @property
-    def local(self):
-        return None
-
-    @property
-    def is_prerelease(self):
-        return False
-
-    @property
-    def is_postrelease(self):
-        return False
-
-    @property
-    def is_devrelease(self):
-        return False
-
-
-_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
-
-_legacy_version_replacement_map = {
-    "pre": "c",
-    "preview": "c",
-    "-": "final-",
-    "rc": "c",
-    "dev": "@",
-}
-
-
-def _parse_version_parts(s):
-    for part in _legacy_version_component_re.split(s):
-        part = _legacy_version_replacement_map.get(part, part)
-
-        if not part or part == ".":
-            continue
-
-        if part[:1] in "0123456789":
-            # pad for numeric comparison
-            yield part.zfill(8)
-        else:
-            yield "*" + part
-
-    # ensure that alpha/beta/candidate are before final
-    yield "*final"
-
-
-def _legacy_cmpkey(version):
-    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
-    # greater than or equal to 0. This will effectively put the LegacyVersion,
-    # which uses the defacto standard originally implemented by setuptools,
-    # as before all PEP 440 versions.
-    epoch = -1
-
-    # This scheme is taken from pkg_resources.parse_version setuptools prior to
-    # it's adoption of the packaging library.
-    parts = []
-    for part in _parse_version_parts(version.lower()):
-        if part.startswith("*"):
-            # remove "-" before a prerelease tag
-            if part < "*final":
-                while parts and parts[-1] == "*final-":
-                    parts.pop()
-
-            # remove trailing zeros from each series of numeric parts
-            while parts and parts[-1] == "00000000":
-                parts.pop()
-
-        parts.append(part)
-    parts = tuple(parts)
-
-    return epoch, parts
-
-
-# Deliberately not anchored to the start and end of the string, to make it
-# easier for 3rd party code to reuse
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-
-class Version(_BaseVersion):
-
-    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    def __init__(self, version):
-        # Validate the version and parse it into pieces
-        match = self._regex.search(version)
-        if not match:
-            raise InvalidVersion("Invalid version: '{0}'".format(version))
-
-        # Store the parsed out pieces of the version
-        self._version = _Version(
-            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
-            release=tuple(int(i) for i in match.group("release").split(".")),
-            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
-            post=_parse_letter_version(
-                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
-            ),
-            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
-            local=_parse_local_version(match.group("local")),
-        )
-
-        # Generate a key which will be used for sorting
-        self._key = _cmpkey(
-            self._version.epoch,
-            self._version.release,
-            self._version.pre,
-            self._version.post,
-            self._version.dev,
-            self._version.local,
-        )
-
-    def __repr__(self):
-        return "<Version({0})>".format(repr(str(self)))
-
-    def __str__(self):
-        parts = []
-
-        # Epoch
-        if self.epoch != 0:
-            parts.append("{0}!".format(self.epoch))
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self.release))
-
-        # Pre-release
-        if self.pre is not None:
-            parts.append("".join(str(x) for x in self.pre))
-
-        # Post-release
-        if self.post is not None:
-            parts.append(".post{0}".format(self.post))
-
-        # Development release
-        if self.dev is not None:
-            parts.append(".dev{0}".format(self.dev))
-
-        # Local version segment
-        if self.local is not None:
-            parts.append("+{0}".format(self.local))
-
-        return "".join(parts)
-
-    @property
-    def epoch(self):
-        return self._version.epoch
-
-    @property
-    def release(self):
-        return self._version.release
-
-    @property
-    def pre(self):
-        return self._version.pre
-
-    @property
-    def post(self):
-        return self._version.post[1] if self._version.post else None
-
-    @property
-    def dev(self):
-        return self._version.dev[1] if self._version.dev else None
-
-    @property
-    def local(self):
-        if self._version.local:
-            return ".".join(str(x) for x in self._version.local)
-        else:
-            return None
-
-    @property
-    def public(self):
-        return str(self).split("+", 1)[0]
-
-    @property
-    def base_version(self):
-        parts = []
-
-        # Epoch
-        if self.epoch != 0:
-            parts.append("{0}!".format(self.epoch))
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self.release))
-
-        return "".join(parts)
-
-    @property
-    def is_prerelease(self):
-        return self.dev is not None or self.pre is not None
-
-    @property
-    def is_postrelease(self):
-        return self.post is not None
-
-    @property
-    def is_devrelease(self):
-        return self.dev is not None
-
-
-def _parse_letter_version(letter, number):
-    if letter:
-        # We consider there to be an implicit 0 in a pre-release if there is
-        # not a numeral associated with it.
-        if number is None:
-            number = 0
-
-        # We normalize any letters to their lower case form
-        letter = letter.lower()
-
-        # We consider some words to be alternate spellings of other words and
-        # in those cases we want to normalize the spellings to our preferred
-        # spelling.
-        if letter == "alpha":
-            letter = "a"
-        elif letter == "beta":
-            letter = "b"
-        elif letter in ["c", "pre", "preview"]:
-            letter = "rc"
-        elif letter in ["rev", "r"]:
-            letter = "post"
-
-        return letter, int(number)
-    if not letter and number:
-        # We assume if we are given a number, but we are not given a letter
-        # then this is using the implicit post release syntax (e.g. 1.0-1)
-        letter = "post"
-
-        return letter, int(number)
-
-
-_local_version_separators = re.compile(r"[\._-]")
-
-
-def _parse_local_version(local):
-    """
-    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
-    """
-    if local is not None:
-        return tuple(
-            part.lower() if not part.isdigit() else int(part)
-            for part in _local_version_separators.split(local)
-        )
-
-
-def _cmpkey(epoch, release, pre, post, dev, local):
-    # When we compare a release version, we want to compare it with all of the
-    # trailing zeros removed. So we'll use a reverse the list, drop all the now
-    # leading zeros until we come to something non zero, then take the rest
-    # re-reverse it back into the correct order and make it a tuple and use
-    # that for our sorting key.
-    release = tuple(
-        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
-    )
-
-    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
-    # We'll do this by abusing the pre segment, but we _only_ want to do this
-    # if there is not a pre or a post segment. If we have one of those then
-    # the normal sorting rules will handle this case correctly.
-    if pre is None and post is None and dev is not None:
-        pre = -Infinity
-    # Versions without a pre-release (except as noted above) should sort after
-    # those with one.
-    elif pre is None:
-        pre = Infinity
-
-    # Versions without a post segment should sort before those with one.
-    if post is None:
-        post = -Infinity
-
-    # Versions without a development segment should sort after those with one.
-    if dev is None:
-        dev = Infinity
-
-    if local is None:
-        # Versions without a local segment should sort before those with one.
-        local = -Infinity
-    else:
-        # Versions with a local segment need that segment parsed to implement
-        # the sorting rules in PEP440.
-        # - Alpha numeric segments sort before numeric segments
-        # - Alpha numeric segments sort lexicographically
-        # - Numeric segments sort numerically
-        # - Shorter versions sort before longer versions when the prefixes
-        #   match exactly
-        local = tuple((i, "") if isinstance(i, int) else (-Infinity, i) for i in local)
-
-    return epoch, release, pre, post, dev, local
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import collections 
+import itertools 
+import re 
+ 
+from ._structures import Infinity 
+ 
+ 
+__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"] 
+ 
+ 
+_Version = collections.namedtuple( 
+    "_Version", ["epoch", "release", "dev", "pre", "post", "local"] 
+) 
+ 
+ 
+def parse(version): 
+    """ 
+    Parse the given version string and return either a :class:`Version` object 
+    or a :class:`LegacyVersion` object depending on if the given version is 
+    a valid PEP 440 version or a legacy version. 
+    """ 
+    try: 
+        return Version(version) 
+    except InvalidVersion: 
+        return LegacyVersion(version) 
+ 
+ 
+class InvalidVersion(ValueError): 
+    """ 
+    An invalid version was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
+class _BaseVersion(object): 
+    def __hash__(self): 
+        return hash(self._key) 
+ 
+    def __lt__(self, other): 
+        return self._compare(other, lambda s, o: s < o) 
+ 
+    def __le__(self, other): 
+        return self._compare(other, lambda s, o: s <= o) 
+ 
+    def __eq__(self, other): 
+        return self._compare(other, lambda s, o: s == o) 
+ 
+    def __ge__(self, other): 
+        return self._compare(other, lambda s, o: s >= o) 
+ 
+    def __gt__(self, other): 
+        return self._compare(other, lambda s, o: s > o) 
+ 
+    def __ne__(self, other): 
+        return self._compare(other, lambda s, o: s != o) 
+ 
+    def _compare(self, other, method): 
+        if not isinstance(other, _BaseVersion): 
+            return NotImplemented 
+ 
+        return method(self._key, other._key) 
+ 
+ 
+class LegacyVersion(_BaseVersion): 
+    def __init__(self, version): 
+        self._version = str(version) 
+        self._key = _legacy_cmpkey(self._version) 
+ 
+    def __str__(self): 
+        return self._version 
+ 
+    def __repr__(self): 
+        return "<LegacyVersion({0})>".format(repr(str(self))) 
+ 
+    @property 
+    def public(self): 
+        return self._version 
+ 
+    @property 
+    def base_version(self): 
+        return self._version 
+ 
+    @property 
+    def epoch(self): 
+        return -1 
+ 
+    @property 
+    def release(self): 
+        return None 
+ 
+    @property 
+    def pre(self): 
+        return None 
+ 
+    @property 
+    def post(self): 
+        return None 
+ 
+    @property 
+    def dev(self): 
+        return None 
+ 
+    @property 
+    def local(self): 
+        return None 
+ 
+    @property 
+    def is_prerelease(self): 
+        return False 
+ 
+    @property 
+    def is_postrelease(self): 
+        return False 
+ 
+    @property 
+    def is_devrelease(self): 
+        return False 
+ 
+ 
+_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE) 
+ 
+_legacy_version_replacement_map = { 
+    "pre": "c", 
+    "preview": "c", 
+    "-": "final-", 
+    "rc": "c", 
+    "dev": "@", 
+} 
+ 
+ 
+def _parse_version_parts(s): 
+    for part in _legacy_version_component_re.split(s): 
+        part = _legacy_version_replacement_map.get(part, part) 
+ 
+        if not part or part == ".": 
+            continue 
+ 
+        if part[:1] in "0123456789": 
+            # pad for numeric comparison 
+            yield part.zfill(8) 
+        else: 
+            yield "*" + part 
+ 
+    # ensure that alpha/beta/candidate are before final 
+    yield "*final" 
+ 
+ 
+def _legacy_cmpkey(version): 
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch 
+    # greater than or equal to 0. This will effectively put the LegacyVersion, 
+    # which uses the defacto standard originally implemented by setuptools, 
+    # as before all PEP 440 versions. 
+    epoch = -1 
+ 
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to 
+    # it's adoption of the packaging library. 
+    parts = [] 
+    for part in _parse_version_parts(version.lower()): 
+        if part.startswith("*"): 
+            # remove "-" before a prerelease tag 
+            if part < "*final": 
+                while parts and parts[-1] == "*final-": 
+                    parts.pop() 
+ 
+            # remove trailing zeros from each series of numeric parts 
+            while parts and parts[-1] == "00000000": 
+                parts.pop() 
+ 
+        parts.append(part) 
+    parts = tuple(parts) 
+ 
+    return epoch, parts 
+ 
+ 
+# Deliberately not anchored to the start and end of the string, to make it 
+# easier for 3rd party code to reuse 
+VERSION_PATTERN = r""" 
+    v? 
+    (?: 
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch 
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment 
+        (?P<pre>                                          # pre-release 
+            [-_\.]? 
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview)) 
+            [-_\.]? 
+            (?P<pre_n>[0-9]+)? 
+        )? 
+        (?P<post>                                         # post release 
+            (?:-(?P<post_n1>[0-9]+)) 
+            | 
+            (?: 
+                [-_\.]? 
+                (?P<post_l>post|rev|r) 
+                [-_\.]? 
+                (?P<post_n2>[0-9]+)? 
+            ) 
+        )? 
+        (?P<dev>                                          # dev release 
+            [-_\.]? 
+            (?P<dev_l>dev) 
+            [-_\.]? 
+            (?P<dev_n>[0-9]+)? 
+        )? 
+    ) 
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version 
+""" 
+ 
+ 
+class Version(_BaseVersion): 
+ 
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE) 
+ 
+    def __init__(self, version): 
+        # Validate the version and parse it into pieces 
+        match = self._regex.search(version) 
+        if not match: 
+            raise InvalidVersion("Invalid version: '{0}'".format(version)) 
+ 
+        # Store the parsed out pieces of the version 
+        self._version = _Version( 
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0, 
+            release=tuple(int(i) for i in match.group("release").split(".")), 
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")), 
+            post=_parse_letter_version( 
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2") 
+            ), 
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")), 
+            local=_parse_local_version(match.group("local")), 
+        ) 
+ 
+        # Generate a key which will be used for sorting 
+        self._key = _cmpkey( 
+            self._version.epoch, 
+            self._version.release, 
+            self._version.pre, 
+            self._version.post, 
+            self._version.dev, 
+            self._version.local, 
+        ) 
+ 
+    def __repr__(self): 
+        return "<Version({0})>".format(repr(str(self))) 
+ 
+    def __str__(self): 
+        parts = [] 
+ 
+        # Epoch 
+        if self.epoch != 0: 
+            parts.append("{0}!".format(self.epoch)) 
+ 
+        # Release segment 
+        parts.append(".".join(str(x) for x in self.release)) 
+ 
+        # Pre-release 
+        if self.pre is not None: 
+            parts.append("".join(str(x) for x in self.pre)) 
+ 
+        # Post-release 
+        if self.post is not None: 
+            parts.append(".post{0}".format(self.post)) 
+ 
+        # Development release 
+        if self.dev is not None: 
+            parts.append(".dev{0}".format(self.dev)) 
+ 
+        # Local version segment 
+        if self.local is not None: 
+            parts.append("+{0}".format(self.local)) 
+ 
+        return "".join(parts) 
+ 
+    @property 
+    def epoch(self): 
+        return self._version.epoch 
+ 
+    @property 
+    def release(self): 
+        return self._version.release 
+ 
+    @property 
+    def pre(self): 
+        return self._version.pre 
+ 
+    @property 
+    def post(self): 
+        return self._version.post[1] if self._version.post else None 
+ 
+    @property 
+    def dev(self): 
+        return self._version.dev[1] if self._version.dev else None 
+ 
+    @property 
+    def local(self): 
+        if self._version.local: 
+            return ".".join(str(x) for x in self._version.local) 
+        else: 
+            return None 
+ 
+    @property 
+    def public(self): 
+        return str(self).split("+", 1)[0] 
+ 
+    @property 
+    def base_version(self): 
+        parts = [] 
+ 
+        # Epoch 
+        if self.epoch != 0: 
+            parts.append("{0}!".format(self.epoch)) 
+ 
+        # Release segment 
+        parts.append(".".join(str(x) for x in self.release)) 
+ 
+        return "".join(parts) 
+ 
+    @property 
+    def is_prerelease(self): 
+        return self.dev is not None or self.pre is not None 
+ 
+    @property 
+    def is_postrelease(self): 
+        return self.post is not None 
+ 
+    @property 
+    def is_devrelease(self): 
+        return self.dev is not None 
+ 
+ 
+def _parse_letter_version(letter, number): 
+    if letter: 
+        # We consider there to be an implicit 0 in a pre-release if there is 
+        # not a numeral associated with it. 
+        if number is None: 
+            number = 0 
+ 
+        # We normalize any letters to their lower case form 
+        letter = letter.lower() 
+ 
+        # We consider some words to be alternate spellings of other words and 
+        # in those cases we want to normalize the spellings to our preferred 
+        # spelling. 
+        if letter == "alpha": 
+            letter = "a" 
+        elif letter == "beta": 
+            letter = "b" 
+        elif letter in ["c", "pre", "preview"]: 
+            letter = "rc" 
+        elif letter in ["rev", "r"]: 
+            letter = "post" 
+ 
+        return letter, int(number) 
+    if not letter and number: 
+        # We assume if we are given a number, but we are not given a letter 
+        # then this is using the implicit post release syntax (e.g. 1.0-1) 
+        letter = "post" 
+ 
+        return letter, int(number) 
+ 
+ 
+_local_version_separators = re.compile(r"[\._-]") 
+ 
+ 
+def _parse_local_version(local): 
+    """ 
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). 
+    """ 
+    if local is not None: 
+        return tuple( 
+            part.lower() if not part.isdigit() else int(part) 
+            for part in _local_version_separators.split(local) 
+        ) 
+ 
+ 
+def _cmpkey(epoch, release, pre, post, dev, local): 
+    # When we compare a release version, we want to compare it with all of the 
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now 
+    # leading zeros until we come to something non zero, then take the rest 
+    # re-reverse it back into the correct order and make it a tuple and use 
+    # that for our sorting key. 
+    release = tuple( 
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release)))) 
+    ) 
+ 
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0. 
+    # We'll do this by abusing the pre segment, but we _only_ want to do this 
+    # if there is not a pre or a post segment. If we have one of those then 
+    # the normal sorting rules will handle this case correctly. 
+    if pre is None and post is None and dev is not None: 
+        pre = -Infinity 
+    # Versions without a pre-release (except as noted above) should sort after 
+    # those with one. 
+    elif pre is None: 
+        pre = Infinity 
+ 
+    # Versions without a post segment should sort before those with one. 
+    if post is None: 
+        post = -Infinity 
+ 
+    # Versions without a development segment should sort after those with one. 
+    if dev is None: 
+        dev = Infinity 
+ 
+    if local is None: 
+        # Versions without a local segment should sort before those with one. 
+        local = -Infinity 
+    else: 
+        # Versions with a local segment need that segment parsed to implement 
+        # the sorting rules in PEP440. 
+        # - Alpha numeric segments sort before numeric segments 
+        # - Alpha numeric segments sort lexicographically 
+        # - Numeric segments sort numerically 
+        # - Shorter versions sort before longer versions when the prefixes 
+        #   match exactly 
+        local = tuple((i, "") if isinstance(i, int) else (-Infinity, i) for i in local) 
+ 
+    return epoch, release, pre, post, dev, local 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/pyparsing.py b/contrib/python/setuptools/py2/setuptools/_vendor/pyparsing.py
index cf75e1e5fc..b4a0aa3221 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/pyparsing.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/pyparsing.py
@@ -1,5742 +1,5742 @@
-# module pyparsing.py

-#

-# Copyright (c) 2003-2018  Paul T. McGuire

-#

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

-#

-

-__doc__ = \

-"""

-pyparsing module - Classes and methods to define and execute parsing grammars

-=============================================================================

-

-The pyparsing module is an alternative approach to creating and executing simple grammars,

-vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you

-don't need to learn a new syntax for defining grammars or matching expressions - the parsing module

-provides a library of classes that you use to construct the grammar directly in Python.

-

-Here is a program to parse "Hello, World!" (or any greeting of the form 

-C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements 

-(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to

-L{Literal} expressions)::

-

-    from pyparsing import Word, alphas

-

-    # define grammar of a greeting

-    greet = Word(alphas) + "," + Word(alphas) + "!"

-

-    hello = "Hello, World!"

-    print (hello, "->", greet.parseString(hello))

-

-The program outputs the following::

-

-    Hello, World! -> ['Hello', ',', 'World', '!']

-

-The Python representation of the grammar is quite readable, owing to the self-explanatory

-class names, and the use of '+', '|' and '^' operators.

-

-The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an

-object with named attributes.

-

-The pyparsing module handles some of the problems that are typically vexing when writing text parsers:

- - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)

- - quoted strings

- - embedded comments

-

-

-Getting Started -

------------------

-Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing

-classes inherit from. Use the docstrings for examples of how to:

- - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes

- - construct character word-group expressions using the L{Word} class

- - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes

- - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones

- - associate names with your parsed results using L{ParserElement.setResultsName}

- - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}

- - find more useful common expressions in the L{pyparsing_common} namespace class

-"""

-

-__version__ = "2.2.1"

-__versionTime__ = "18 Sep 2018 00:49 UTC"

-__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"

-

-import string

-from weakref import ref as wkref

-import copy

-import sys

-import warnings

-import re

-import sre_constants

-import collections

-import pprint

-import traceback

-import types

-from datetime import datetime

-

-try:

-    from _thread import RLock

-except ImportError:

-    from threading import RLock

-

-try:

-    # Python 3

-    from collections.abc import Iterable

-    from collections.abc import MutableMapping

-except ImportError:

-    # Python 2.7

-    from collections import Iterable

-    from collections import MutableMapping

-

-try:

-    from collections import OrderedDict as _OrderedDict

-except ImportError:

-    try:

-        from ordereddict import OrderedDict as _OrderedDict

-    except ImportError:

-        _OrderedDict = None

-

-#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )

-

-__all__ = [

-'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',

-'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',

-'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',

-'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',

-'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',

-'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 

-'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',

-'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',

-'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',

-'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',

-'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',

-'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',

-'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',

-'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 

-'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',

-'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',

-'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',

-'CloseMatch', 'tokenMap', 'pyparsing_common',

-]

-

-system_version = tuple(sys.version_info)[:3]

-PY_3 = system_version[0] == 3

-if PY_3:

-    _MAX_INT = sys.maxsize

-    basestring = str

-    unichr = chr

-    _ustr = str

-

-    # build list of single arg builtins, that can be used as parse actions

-    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]

-

-else:

-    _MAX_INT = sys.maxint

-    range = xrange

-

-    def _ustr(obj):

-        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries

-           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It

-           then < returns the unicode object | encodes it with the default encoding | ... >.

-        """

-        if isinstance(obj,unicode):

-            return obj

-

-        try:

-            # If this works, then _ustr(obj) has the same behaviour as str(obj), so

-            # it won't break any existing code.

-            return str(obj)

-

-        except UnicodeEncodeError:

-            # Else encode it

-            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')

-            xmlcharref = Regex(r'&#\d+;')

-            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])

-            return xmlcharref.transformString(ret)

-

-    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions

-    singleArgBuiltins = []

-    import __builtin__

-    for fname in "sum len sorted reversed list tuple set any all min max".split():

-        try:

-            singleArgBuiltins.append(getattr(__builtin__,fname))

-        except AttributeError:

-            continue

-            

-_generatorType = type((y for y in range(1)))

- 

-def _xml_escape(data):

-    """Escape &, <, >, ", ', etc. in a string of data."""

-

-    # ampersand must be replaced first

-    from_symbols = '&><"\''

-    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())

-    for from_,to_ in zip(from_symbols, to_symbols):

-        data = data.replace(from_, to_)

-    return data

-

-class _Constants(object):

-    pass

-

-alphas     = string.ascii_uppercase + string.ascii_lowercase

-nums       = "0123456789"

-hexnums    = nums + "ABCDEFabcdef"

-alphanums  = alphas + nums

-_bslash    = chr(92)

-printables = "".join(c for c in string.printable if c not in string.whitespace)

-

-class ParseBaseException(Exception):

-    """base exception class for all parsing runtime exceptions"""

-    # Performance tuning: we construct a *lot* of these, so keep this

-    # constructor as small and fast as possible

-    def __init__( self, pstr, loc=0, msg=None, elem=None ):

-        self.loc = loc

-        if msg is None:

-            self.msg = pstr

-            self.pstr = ""

-        else:

-            self.msg = msg

-            self.pstr = pstr

-        self.parserElement = elem

-        self.args = (pstr, loc, msg)

-

-    @classmethod

-    def _from_exception(cls, pe):

-        """

-        internal factory method to simplify creating one type of ParseException 

-        from another - avoids having __init__ signature conflicts among subclasses

-        """

-        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)

-

-    def __getattr__( self, aname ):

-        """supported attributes by name are:

-            - lineno - returns the line number of the exception text

-            - col - returns the column number of the exception text

-            - line - returns the line containing the exception text

-        """

-        if( aname == "lineno" ):

-            return lineno( self.loc, self.pstr )

-        elif( aname in ("col", "column") ):

-            return col( self.loc, self.pstr )

-        elif( aname == "line" ):

-            return line( self.loc, self.pstr )

-        else:

-            raise AttributeError(aname)

-

-    def __str__( self ):

-        return "%s (at char %d), (line:%d, col:%d)" % \

-                ( self.msg, self.loc, self.lineno, self.column )

-    def __repr__( self ):

-        return _ustr(self)

-    def markInputline( self, markerString = ">!<" ):

-        """Extracts the exception line from the input string, and marks

-           the location of the exception with a special symbol.

-        """

-        line_str = self.line

-        line_column = self.column - 1

-        if markerString:

-            line_str = "".join((line_str[:line_column],

-                                markerString, line_str[line_column:]))

-        return line_str.strip()

-    def __dir__(self):

-        return "lineno col line".split() + dir(type(self))

-

-class ParseException(ParseBaseException):

-    """

-    Exception thrown when parse expressions don't match class;

-    supported attributes by name are:

-     - lineno - returns the line number of the exception text

-     - col - returns the column number of the exception text

-     - line - returns the line containing the exception text

-        

-    Example::

-        try:

-            Word(nums).setName("integer").parseString("ABC")

-        except ParseException as pe:

-            print(pe)

-            print("column: {}".format(pe.col))

-            

-    prints::

-       Expected integer (at char 0), (line:1, col:1)

-        column: 1

-    """

-    pass

-

-class ParseFatalException(ParseBaseException):

-    """user-throwable exception thrown when inconsistent parse content

-       is found; stops all parsing immediately"""

-    pass

-

-class ParseSyntaxException(ParseFatalException):

-    """just like L{ParseFatalException}, but thrown internally when an

-       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop 

-       immediately because an unbacktrackable syntax error has been found"""

-    pass

-

-#~ class ReparseException(ParseBaseException):

-    #~ """Experimental class - parse actions can raise this exception to cause

-       #~ pyparsing to reparse the input string:

-        #~ - with a modified input string, and/or

-        #~ - with a modified start location

-       #~ Set the values of the ReparseException in the constructor, and raise the

-       #~ exception in a parse action to cause pyparsing to use the new string/location.

-       #~ Setting the values as None causes no change to be made.

-       #~ """

-    #~ def __init_( self, newstring, restartLoc ):

-        #~ self.newParseText = newstring

-        #~ self.reparseLoc = restartLoc

-

-class RecursiveGrammarException(Exception):

-    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""

-    def __init__( self, parseElementList ):

-        self.parseElementTrace = parseElementList

-

-    def __str__( self ):

-        return "RecursiveGrammarException: %s" % self.parseElementTrace

-

-class _ParseResultsWithOffset(object):

-    def __init__(self,p1,p2):

-        self.tup = (p1,p2)

-    def __getitem__(self,i):

-        return self.tup[i]

-    def __repr__(self):

-        return repr(self.tup[0])

-    def setOffset(self,i):

-        self.tup = (self.tup[0],i)

-

-class ParseResults(object):

-    """

-    Structured parse results, to provide multiple means of access to the parsed data:

-       - as a list (C{len(results)})

-       - by list index (C{results[0], results[1]}, etc.)

-       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName})

-

-    Example::

-        integer = Word(nums)

-        date_str = (integer.setResultsName("year") + '/' 

-                        + integer.setResultsName("month") + '/' 

-                        + integer.setResultsName("day"))

-        # equivalent form:

-        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-

-        # parseString returns a ParseResults object

-        result = date_str.parseString("1999/12/31")

-

-        def test(s, fn=repr):

-            print("%s -> %s" % (s, fn(eval(s))))

-        test("list(result)")

-        test("result[0]")

-        test("result['month']")

-        test("result.day")

-        test("'month' in result")

-        test("'minutes' in result")

-        test("result.dump()", str)

-    prints::

-        list(result) -> ['1999', '/', '12', '/', '31']

-        result[0] -> '1999'

-        result['month'] -> '12'

-        result.day -> '31'

-        'month' in result -> True

-        'minutes' in result -> False

-        result.dump() -> ['1999', '/', '12', '/', '31']

-        - day: 31

-        - month: 12

-        - year: 1999

-    """

-    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):

-        if isinstance(toklist, cls):

-            return toklist

-        retobj = object.__new__(cls)

-        retobj.__doinit = True

-        return retobj

-

-    # Performance tuning: we construct a *lot* of these, so keep this

-    # constructor as small and fast as possible

-    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):

-        if self.__doinit:

-            self.__doinit = False

-            self.__name = None

-            self.__parent = None

-            self.__accumNames = {}

-            self.__asList = asList

-            self.__modal = modal

-            if toklist is None:

-                toklist = []

-            if isinstance(toklist, list):

-                self.__toklist = toklist[:]

-            elif isinstance(toklist, _generatorType):

-                self.__toklist = list(toklist)

-            else:

-                self.__toklist = [toklist]

-            self.__tokdict = dict()

-

-        if name is not None and name:

-            if not modal:

-                self.__accumNames[name] = 0

-            if isinstance(name,int):

-                name = _ustr(name) # will always return a str, but use _ustr for consistency

-            self.__name = name

-            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):

-                if isinstance(toklist,basestring):

-                    toklist = [ toklist ]

-                if asList:

-                    if isinstance(toklist,ParseResults):

-                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)

-                    else:

-                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)

-                    self[name].__name = name

-                else:

-                    try:

-                        self[name] = toklist[0]

-                    except (KeyError,TypeError,IndexError):

-                        self[name] = toklist

-

-    def __getitem__( self, i ):

-        if isinstance( i, (int,slice) ):

-            return self.__toklist[i]

-        else:

-            if i not in self.__accumNames:

-                return self.__tokdict[i][-1][0]

-            else:

-                return ParseResults([ v[0] for v in self.__tokdict[i] ])

-

-    def __setitem__( self, k, v, isinstance=isinstance ):

-        if isinstance(v,_ParseResultsWithOffset):

-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]

-            sub = v[0]

-        elif isinstance(k,(int,slice)):

-            self.__toklist[k] = v

-            sub = v

-        else:

-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]

-            sub = v

-        if isinstance(sub,ParseResults):

-            sub.__parent = wkref(self)

-

-    def __delitem__( self, i ):

-        if isinstance(i,(int,slice)):

-            mylen = len( self.__toklist )

-            del self.__toklist[i]

-

-            # convert int to slice

-            if isinstance(i, int):

-                if i < 0:

-                    i += mylen

-                i = slice(i, i+1)

-            # get removed indices

-            removed = list(range(*i.indices(mylen)))

-            removed.reverse()

-            # fixup indices in token dictionary

-            for name,occurrences in self.__tokdict.items():

-                for j in removed:

-                    for k, (value, position) in enumerate(occurrences):

-                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))

-        else:

-            del self.__tokdict[i]

-

-    def __contains__( self, k ):

-        return k in self.__tokdict

-

-    def __len__( self ): return len( self.__toklist )

-    def __bool__(self): return ( not not self.__toklist )

-    __nonzero__ = __bool__

-    def __iter__( self ): return iter( self.__toklist )

-    def __reversed__( self ): return iter( self.__toklist[::-1] )

-    def _iterkeys( self ):

-        if hasattr(self.__tokdict, "iterkeys"):

-            return self.__tokdict.iterkeys()

-        else:

-            return iter(self.__tokdict)

-

-    def _itervalues( self ):

-        return (self[k] for k in self._iterkeys())

-            

-    def _iteritems( self ):

-        return ((k, self[k]) for k in self._iterkeys())

-

-    if PY_3:

-        keys = _iterkeys       

-        """Returns an iterator of all named result keys (Python 3.x only)."""

-

-        values = _itervalues

-        """Returns an iterator of all named result values (Python 3.x only)."""

-

-        items = _iteritems

-        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""

-

-    else:

-        iterkeys = _iterkeys

-        """Returns an iterator of all named result keys (Python 2.x only)."""

-

-        itervalues = _itervalues

-        """Returns an iterator of all named result values (Python 2.x only)."""

-

-        iteritems = _iteritems

-        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""

-

-        def keys( self ):

-            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""

-            return list(self.iterkeys())

-

-        def values( self ):

-            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""

-            return list(self.itervalues())

-                

-        def items( self ):

-            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""

-            return list(self.iteritems())

-

-    def haskeys( self ):

-        """Since keys() returns an iterator, this method is helpful in bypassing

-           code that looks for the existence of any defined results names."""

-        return bool(self.__tokdict)

-        

-    def pop( self, *args, **kwargs):

-        """

-        Removes and returns item at specified index (default=C{last}).

-        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no

-        argument or an integer argument, it will use C{list} semantics

-        and pop tokens from the list of parsed tokens. If passed a 

-        non-integer argument (most likely a string), it will use C{dict}

-        semantics and pop the corresponding value from any defined 

-        results names. A second default return value argument is 

-        supported, just as in C{dict.pop()}.

-

-        Example::

-            def remove_first(tokens):

-                tokens.pop(0)

-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

-            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']

-

-            label = Word(alphas)

-            patt = label("LABEL") + OneOrMore(Word(nums))

-            print(patt.parseString("AAB 123 321").dump())

-

-            # Use pop() in a parse action to remove named result (note that corresponding value is not

-            # removed from list form of results)

-            def remove_LABEL(tokens):

-                tokens.pop("LABEL")

-                return tokens

-            patt.addParseAction(remove_LABEL)

-            print(patt.parseString("AAB 123 321").dump())

-        prints::

-            ['AAB', '123', '321']

-            - LABEL: AAB

-

-            ['AAB', '123', '321']

-        """

-        if not args:

-            args = [-1]

-        for k,v in kwargs.items():

-            if k == 'default':

-                args = (args[0], v)

-            else:

-                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)

-        if (isinstance(args[0], int) or 

-                        len(args) == 1 or 

-                        args[0] in self):

-            index = args[0]

-            ret = self[index]

-            del self[index]

-            return ret

-        else:

-            defaultvalue = args[1]

-            return defaultvalue

-

-    def get(self, key, defaultValue=None):

-        """

-        Returns named result matching the given key, or if there is no

-        such name, then returns the given C{defaultValue} or C{None} if no

-        C{defaultValue} is specified.

-

-        Similar to C{dict.get()}.

-        

-        Example::

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

-

-            result = date_str.parseString("1999/12/31")

-            print(result.get("year")) # -> '1999'

-            print(result.get("hour", "not specified")) # -> 'not specified'

-            print(result.get("hour")) # -> None

-        """

-        if key in self:

-            return self[key]

-        else:

-            return defaultValue

-

-    def insert( self, index, insStr ):

-        """

-        Inserts new element at location index in the list of parsed tokens.

-        

-        Similar to C{list.insert()}.

-

-        Example::

-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

-

-            # use a parse action to insert the parse location in the front of the parsed results

-            def insert_locn(locn, tokens):

-                tokens.insert(0, locn)

-            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']

-        """

-        self.__toklist.insert(index, insStr)

-        # fixup indices in token dictionary

-        for name,occurrences in self.__tokdict.items():

-            for k, (value, position) in enumerate(occurrences):

-                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))

-

-    def append( self, item ):

-        """

-        Add single element to end of ParseResults list of elements.

-

-        Example::

-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']

-            

-            # use a parse action to compute the sum of the parsed integers, and add it to the end

-            def append_sum(tokens):

-                tokens.append(sum(map(int, tokens)))

-            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]

-        """

-        self.__toklist.append(item)

-

-    def extend( self, itemseq ):

-        """

-        Add sequence of elements to end of ParseResults list of elements.

-

-        Example::

-            patt = OneOrMore(Word(alphas))

-            

-            # use a parse action to append the reverse of the matched strings, to make a palindrome

-            def make_palindrome(tokens):

-                tokens.extend(reversed([t[::-1] for t in tokens]))

-                return ''.join(tokens)

-            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'

-        """

-        if isinstance(itemseq, ParseResults):

-            self += itemseq

-        else:

-            self.__toklist.extend(itemseq)

-

-    def clear( self ):

-        """

-        Clear all elements and results names.

-        """

-        del self.__toklist[:]

-        self.__tokdict.clear()

-

-    def __getattr__( self, name ):

-        try:

-            return self[name]

-        except KeyError:

-            return ""

-            

-        if name in self.__tokdict:

-            if name not in self.__accumNames:

-                return self.__tokdict[name][-1][0]

-            else:

-                return ParseResults([ v[0] for v in self.__tokdict[name] ])

-        else:

-            return ""

-

-    def __add__( self, other ):

-        ret = self.copy()

-        ret += other

-        return ret

-

-    def __iadd__( self, other ):

-        if other.__tokdict:

-            offset = len(self.__toklist)

-            addoffset = lambda a: offset if a<0 else a+offset

-            otheritems = other.__tokdict.items()

-            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )

-                                for (k,vlist) in otheritems for v in vlist]

-            for k,v in otherdictitems:

-                self[k] = v

-                if isinstance(v[0],ParseResults):

-                    v[0].__parent = wkref(self)

-            

-        self.__toklist += other.__toklist

-        self.__accumNames.update( other.__accumNames )

-        return self

-

-    def __radd__(self, other):

-        if isinstance(other,int) and other == 0:

-            # useful for merging many ParseResults using sum() builtin

-            return self.copy()

-        else:

-            # this may raise a TypeError - so be it

-            return other + self

-        

-    def __repr__( self ):

-        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )

-

-    def __str__( self ):

-        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'

-

-    def _asStringList( self, sep='' ):

-        out = []

-        for item in self.__toklist:

-            if out and sep:

-                out.append(sep)

-            if isinstance( item, ParseResults ):

-                out += item._asStringList()

-            else:

-                out.append( _ustr(item) )

-        return out

-

-    def asList( self ):

-        """

-        Returns the parse results as a nested list of matching tokens, all converted to strings.

-

-        Example::

-            patt = OneOrMore(Word(alphas))

-            result = patt.parseString("sldkj lsdkj sldkj")

-            # even though the result prints in string-like form, it is actually a pyparsing ParseResults

-            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']

-            

-            # Use asList() to create an actual list

-            result_list = result.asList()

-            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']

-        """

-        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]

-

-    def asDict( self ):

-        """

-        Returns the named parse results as a nested dictionary.

-

-        Example::

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-            

-            result = date_str.parseString('12/31/1999')

-            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})

-            

-            result_dict = result.asDict()

-            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}

-

-            # even though a ParseResults supports dict-like access, sometime you just need to have a dict

-            import json

-            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable

-            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}

-        """

-        if PY_3:

-            item_fn = self.items

-        else:

-            item_fn = self.iteritems

-            

-        def toItem(obj):

-            if isinstance(obj, ParseResults):

-                if obj.haskeys():

-                    return obj.asDict()

-                else:

-                    return [toItem(v) for v in obj]

-            else:

-                return obj

-                

-        return dict((k,toItem(v)) for k,v in item_fn())

-

-    def copy( self ):

-        """

-        Returns a new copy of a C{ParseResults} object.

-        """

-        ret = ParseResults( self.__toklist )

-        ret.__tokdict = self.__tokdict.copy()

-        ret.__parent = self.__parent

-        ret.__accumNames.update( self.__accumNames )

-        ret.__name = self.__name

-        return ret

-

-    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):

-        """

-        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.

-        """

-        nl = "\n"

-        out = []

-        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()

-                                                            for v in vlist)

-        nextLevelIndent = indent + "  "

-

-        # collapse out indents if formatting is not desired

-        if not formatted:

-            indent = ""

-            nextLevelIndent = ""

-            nl = ""

-

-        selfTag = None

-        if doctag is not None:

-            selfTag = doctag

-        else:

-            if self.__name:

-                selfTag = self.__name

-

-        if not selfTag:

-            if namedItemsOnly:

-                return ""

-            else:

-                selfTag = "ITEM"

-

-        out += [ nl, indent, "<", selfTag, ">" ]

-

-        for i,res in enumerate(self.__toklist):

-            if isinstance(res,ParseResults):

-                if i in namedItems:

-                    out += [ res.asXML(namedItems[i],

-                                        namedItemsOnly and doctag is None,

-                                        nextLevelIndent,

-                                        formatted)]

-                else:

-                    out += [ res.asXML(None,

-                                        namedItemsOnly and doctag is None,

-                                        nextLevelIndent,

-                                        formatted)]

-            else:

-                # individual token, see if there is a name for it

-                resTag = None

-                if i in namedItems:

-                    resTag = namedItems[i]

-                if not resTag:

-                    if namedItemsOnly:

-                        continue

-                    else:

-                        resTag = "ITEM"

-                xmlBodyText = _xml_escape(_ustr(res))

-                out += [ nl, nextLevelIndent, "<", resTag, ">",

-                                                xmlBodyText,

-                                                "</", resTag, ">" ]

-

-        out += [ nl, indent, "</", selfTag, ">" ]

-        return "".join(out)

-

-    def __lookup(self,sub):

-        for k,vlist in self.__tokdict.items():

-            for v,loc in vlist:

-                if sub is v:

-                    return k

-        return None

-

-    def getName(self):

-        r"""

-        Returns the results name for this token expression. Useful when several 

-        different expressions might match at a particular location.

-

-        Example::

-            integer = Word(nums)

-            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")

-            house_number_expr = Suppress('#') + Word(nums, alphanums)

-            user_data = (Group(house_number_expr)("house_number") 

-                        | Group(ssn_expr)("ssn")

-                        | Group(integer)("age"))

-            user_info = OneOrMore(user_data)

-            

-            result = user_info.parseString("22 111-22-3333 #221B")

-            for item in result:

-                print(item.getName(), ':', item[0])

-        prints::

-            age : 22

-            ssn : 111-22-3333

-            house_number : 221B

-        """

-        if self.__name:

-            return self.__name

-        elif self.__parent:

-            par = self.__parent()

-            if par:

-                return par.__lookup(self)

-            else:

-                return None

-        elif (len(self) == 1 and

-               len(self.__tokdict) == 1 and

-               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):

-            return next(iter(self.__tokdict.keys()))

-        else:

-            return None

-

-    def dump(self, indent='', depth=0, full=True):

-        """

-        Diagnostic method for listing out the contents of a C{ParseResults}.

-        Accepts an optional C{indent} argument so that this string can be embedded

-        in a nested display of other data.

-

-        Example::

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-            

-            result = date_str.parseString('12/31/1999')

-            print(result.dump())

-        prints::

-            ['12', '/', '31', '/', '1999']

-            - day: 1999

-            - month: 31

-            - year: 12

-        """

-        out = []

-        NL = '\n'

-        out.append( indent+_ustr(self.asList()) )

-        if full:

-            if self.haskeys():

-                items = sorted((str(k), v) for k,v in self.items())

-                for k,v in items:

-                    if out:

-                        out.append(NL)

-                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )

-                    if isinstance(v,ParseResults):

-                        if v:

-                            out.append( v.dump(indent,depth+1) )

-                        else:

-                            out.append(_ustr(v))

-                    else:

-                        out.append(repr(v))

-            elif any(isinstance(vv,ParseResults) for vv in self):

-                v = self

-                for i,vv in enumerate(v):

-                    if isinstance(vv,ParseResults):

-                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))

-                    else:

-                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))

-            

-        return "".join(out)

-

-    def pprint(self, *args, **kwargs):

-        """

-        Pretty-printer for parsed results as a list, using the C{pprint} module.

-        Accepts additional positional or keyword args as defined for the 

-        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})

-

-        Example::

-            ident = Word(alphas, alphanums)

-            num = Word(nums)

-            func = Forward()

-            term = ident | num | Group('(' + func + ')')

-            func <<= ident + Group(Optional(delimitedList(term)))

-            result = func.parseString("fna a,b,(fnb c,d,200),100")

-            result.pprint(width=40)

-        prints::

-            ['fna',

-             ['a',

-              'b',

-              ['(', 'fnb', ['c', 'd', '200'], ')'],

-              '100']]

-        """

-        pprint.pprint(self.asList(), *args, **kwargs)

-

-    # add support for pickle protocol

-    def __getstate__(self):

-        return ( self.__toklist,

-                 ( self.__tokdict.copy(),

-                   self.__parent is not None and self.__parent() or None,

-                   self.__accumNames,

-                   self.__name ) )

-

-    def __setstate__(self,state):

-        self.__toklist = state[0]

-        (self.__tokdict,

-         par,

-         inAccumNames,

-         self.__name) = state[1]

-        self.__accumNames = {}

-        self.__accumNames.update(inAccumNames)

-        if par is not None:

-            self.__parent = wkref(par)

-        else:

-            self.__parent = None

-

-    def __getnewargs__(self):

-        return self.__toklist, self.__name, self.__asList, self.__modal

-

-    def __dir__(self):

-        return (dir(type(self)) + list(self.keys()))

-

-MutableMapping.register(ParseResults)

-

-def col (loc,strg):

-    """Returns current column within a string, counting newlines as line separators.

-   The first column is number 1.

-

-   Note: the default parsing behavior is to expand tabs in the input string

-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information

-   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a

-   consistent view of the parsed string, the parse location, and line and column

-   positions within the parsed string.

-   """

-    s = strg

-    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc)

-

-def lineno(loc,strg):

-    """Returns current line number within a string, counting newlines as line separators.

-   The first line is number 1.

-

-   Note: the default parsing behavior is to expand tabs in the input string

-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information

-   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a

-   consistent view of the parsed string, the parse location, and line and column

-   positions within the parsed string.

-   """

-    return strg.count("\n",0,loc) + 1

-

-def line( loc, strg ):

-    """Returns the line of text containing loc within a string, counting newlines as line separators.

-       """

-    lastCR = strg.rfind("\n", 0, loc)

-    nextCR = strg.find("\n", loc)

-    if nextCR >= 0:

-        return strg[lastCR+1:nextCR]

-    else:

-        return strg[lastCR+1:]

-

-def _defaultStartDebugAction( instring, loc, expr ):

-    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))

-

-def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):

-    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))

-

-def _defaultExceptionDebugAction( instring, loc, expr, exc ):

-    print ("Exception raised:" + _ustr(exc))

-

-def nullDebugAction(*args):

-    """'Do-nothing' debug action, to suppress debugging output during parsing."""

-    pass

-

-# Only works on Python 3.x - nonlocal is toxic to Python 2 installs

-#~ 'decorator to trim function calls to match the arity of the target'

-#~ def _trim_arity(func, maxargs=3):

-    #~ if func in singleArgBuiltins:

-        #~ return lambda s,l,t: func(t)

-    #~ limit = 0

-    #~ foundArity = False

-    #~ def wrapper(*args):

-        #~ nonlocal limit,foundArity

-        #~ while 1:

-            #~ try:

-                #~ ret = func(*args[limit:])

-                #~ foundArity = True

-                #~ return ret

-            #~ except TypeError:

-                #~ if limit == maxargs or foundArity:

-                    #~ raise

-                #~ limit += 1

-                #~ continue

-    #~ return wrapper

-

-# this version is Python 2.x-3.x cross-compatible

-'decorator to trim function calls to match the arity of the target'

-def _trim_arity(func, maxargs=2):

-    if func in singleArgBuiltins:

-        return lambda s,l,t: func(t)

-    limit = [0]

-    foundArity = [False]

-    

-    # traceback return data structure changed in Py3.5 - normalize back to plain tuples

-    if system_version[:2] >= (3,5):

-        def extract_stack(limit=0):

-            # special handling for Python 3.5.0 - extra deep call stack by 1

-            offset = -3 if system_version == (3,5,0) else -2

-            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]

-            return [frame_summary[:2]]

-        def extract_tb(tb, limit=0):

-            frames = traceback.extract_tb(tb, limit=limit)

-            frame_summary = frames[-1]

-            return [frame_summary[:2]]

-    else:

-        extract_stack = traceback.extract_stack

-        extract_tb = traceback.extract_tb

-    

-    # synthesize what would be returned by traceback.extract_stack at the call to 

-    # user's parse action 'func', so that we don't incur call penalty at parse time

-    

-    LINE_DIFF = 6

-    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 

-    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!

-    this_line = extract_stack(limit=2)[-1]

-    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)

-

-    def wrapper(*args):

-        while 1:

-            try:

-                ret = func(*args[limit[0]:])

-                foundArity[0] = True

-                return ret

-            except TypeError:

-                # re-raise TypeErrors if they did not come from our arity testing

-                if foundArity[0]:

-                    raise

-                else:

-                    try:

-                        tb = sys.exc_info()[-1]

-                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:

-                            raise

-                    finally:

-                        del tb

-

-                if limit[0] <= maxargs:

-                    limit[0] += 1

-                    continue

-                raise

-

-    # copy func name to wrapper for sensible debug output

-    func_name = "<parse action>"

-    try:

-        func_name = getattr(func, '__name__', 

-                            getattr(func, '__class__').__name__)

-    except Exception:

-        func_name = str(func)

-    wrapper.__name__ = func_name

-

-    return wrapper

-

-class ParserElement(object):

-    """Abstract base level parser element class."""

-    DEFAULT_WHITE_CHARS = " \n\t\r"

-    verbose_stacktrace = False

-

-    @staticmethod

-    def setDefaultWhitespaceChars( chars ):

-        r"""

-        Overrides the default whitespace chars

-

-        Example::

-            # default whitespace chars are space, <TAB> and newline

-            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']

-            

-            # change to just treat newline as significant

-            ParserElement.setDefaultWhitespaceChars(" \t")

-            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']

-        """

-        ParserElement.DEFAULT_WHITE_CHARS = chars

-

-    @staticmethod

-    def inlineLiteralsUsing(cls):

-        """

-        Set class to be used for inclusion of string literals into a parser.

-        

-        Example::

-            # default literal class used is Literal

-            integer = Word(nums)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

-

-            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']

-

-

-            # change to Suppress

-            ParserElement.inlineLiteralsUsing(Suppress)

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           

-

-            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']

-        """

-        ParserElement._literalStringClass = cls

-

-    def __init__( self, savelist=False ):

-        self.parseAction = list()

-        self.failAction = None

-        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall

-        self.strRepr = None

-        self.resultsName = None

-        self.saveAsList = savelist

-        self.skipWhitespace = True

-        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS

-        self.copyDefaultWhiteChars = True

-        self.mayReturnEmpty = False # used when checking for left-recursion

-        self.keepTabs = False

-        self.ignoreExprs = list()

-        self.debug = False

-        self.streamlined = False

-        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index

-        self.errmsg = ""

-        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)

-        self.debugActions = ( None, None, None ) #custom debug actions

-        self.re = None

-        self.callPreparse = True # used to avoid redundant calls to preParse

-        self.callDuringTry = False

-

-    def copy( self ):

-        """

-        Make a copy of this C{ParserElement}.  Useful for defining different parse actions

-        for the same parsing pattern, using copies of the original parse element.

-        

-        Example::

-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))

-            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")

-            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")

-            

-            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))

-        prints::

-            [5120, 100, 655360, 268435456]

-        Equivalent form of C{expr.copy()} is just C{expr()}::

-            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")

-        """

-        cpy = copy.copy( self )

-        cpy.parseAction = self.parseAction[:]

-        cpy.ignoreExprs = self.ignoreExprs[:]

-        if self.copyDefaultWhiteChars:

-            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS

-        return cpy

-

-    def setName( self, name ):

-        """

-        Define name for this expression, makes debugging and exception messages clearer.

-        

-        Example::

-            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)

-            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)

-        """

-        self.name = name

-        self.errmsg = "Expected " + self.name

-        if hasattr(self,"exception"):

-            self.exception.msg = self.errmsg

-        return self

-

-    def setResultsName( self, name, listAllMatches=False ):

-        """

-        Define name for referencing matching tokens as a nested attribute

-        of the returned parse results.

-        NOTE: this returns a *copy* of the original C{ParserElement} object;

-        this is so that the client can define a basic element, such as an

-        integer, and reference it in multiple places with different names.

-

-        You can also set results names using the abbreviated syntax,

-        C{expr("name")} in place of C{expr.setResultsName("name")} - 

-        see L{I{__call__}<__call__>}.

-

-        Example::

-            date_str = (integer.setResultsName("year") + '/' 

-                        + integer.setResultsName("month") + '/' 

-                        + integer.setResultsName("day"))

-

-            # equivalent form:

-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")

-        """

-        newself = self.copy()

-        if name.endswith("*"):

-            name = name[:-1]

-            listAllMatches=True

-        newself.resultsName = name

-        newself.modalResults = not listAllMatches

-        return newself

-

-    def setBreak(self,breakFlag = True):

-        """Method to invoke the Python pdb debugger when this element is

-           about to be parsed. Set C{breakFlag} to True to enable, False to

-           disable.

-        """

-        if breakFlag:

-            _parseMethod = self._parse

-            def breaker(instring, loc, doActions=True, callPreParse=True):

-                import pdb

-                pdb.set_trace()

-                return _parseMethod( instring, loc, doActions, callPreParse )

-            breaker._originalParseMethod = _parseMethod

-            self._parse = breaker

-        else:

-            if hasattr(self._parse,"_originalParseMethod"):

-                self._parse = self._parse._originalParseMethod

-        return self

-

-    def setParseAction( self, *fns, **kwargs ):

-        """

-        Define one or more actions to perform when successfully matching parse element definition.

-        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},

-        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:

-         - s   = the original string being parsed (see note below)

-         - loc = the location of the matching substring

-         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object

-        If the functions in fns modify the tokens, they can return them as the return

-        value from fn, and the modified list of tokens will replace the original.

-        Otherwise, fn does not need to return any value.

-

-        Optional keyword arguments:

-         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing

-

-        Note: the default parsing behavior is to expand tabs in the input string

-        before starting the parsing process.  See L{I{parseString}<parseString>} for more information

-        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a

-        consistent view of the parsed string, the parse location, and line and column

-        positions within the parsed string.

-        

-        Example::

-            integer = Word(nums)

-            date_str = integer + '/' + integer + '/' + integer

-

-            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']

-

-            # use parse action to convert to ints at parse time

-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))

-            date_str = integer + '/' + integer + '/' + integer

-

-            # note that integer fields are now ints, not strings

-            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]

-        """

-        self.parseAction = list(map(_trim_arity, list(fns)))

-        self.callDuringTry = kwargs.get("callDuringTry", False)

-        return self

-

-    def addParseAction( self, *fns, **kwargs ):

-        """

-        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.

-        

-        See examples in L{I{copy}<copy>}.

-        """

-        self.parseAction += list(map(_trim_arity, list(fns)))

-        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)

-        return self

-

-    def addCondition(self, *fns, **kwargs):

-        """Add a boolean predicate function to expression's list of parse actions. See 

-        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction}, 

-        functions passed to C{addCondition} need to return boolean success/fail of the condition.

-

-        Optional keyword arguments:

-         - message = define a custom message to be used in the raised exception

-         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException

-         

-        Example::

-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))

-            year_int = integer.copy()

-            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")

-            date_str = year_int + '/' + integer + '/' + integer

-

-            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)

-        """

-        msg = kwargs.get("message", "failed user-defined condition")

-        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException

-        for fn in fns:

-            def pa(s,l,t):

-                if not bool(_trim_arity(fn)(s,l,t)):

-                    raise exc_type(s,l,msg)

-            self.parseAction.append(pa)

-        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)

-        return self

-

-    def setFailAction( self, fn ):

-        """Define action to perform if parsing fails at this expression.

-           Fail acton fn is a callable function that takes the arguments

-           C{fn(s,loc,expr,err)} where:

-            - s = string being parsed

-            - loc = location where expression match was attempted and failed

-            - expr = the parse expression that failed

-            - err = the exception thrown

-           The function returns no value.  It may throw C{L{ParseFatalException}}

-           if it is desired to stop parsing immediately."""

-        self.failAction = fn

-        return self

-

-    def _skipIgnorables( self, instring, loc ):

-        exprsFound = True

-        while exprsFound:

-            exprsFound = False

-            for e in self.ignoreExprs:

-                try:

-                    while 1:

-                        loc,dummy = e._parse( instring, loc )

-                        exprsFound = True

-                except ParseException:

-                    pass

-        return loc

-

-    def preParse( self, instring, loc ):

-        if self.ignoreExprs:

-            loc = self._skipIgnorables( instring, loc )

-

-        if self.skipWhitespace:

-            wt = self.whiteChars

-            instrlen = len(instring)

-            while loc < instrlen and instring[loc] in wt:

-                loc += 1

-

-        return loc

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        return loc, []

-

-    def postParse( self, instring, loc, tokenlist ):

-        return tokenlist

-

-    #~ @profile

-    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):

-        debugging = ( self.debug ) #and doActions )

-

-        if debugging or self.failAction:

-            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))

-            if (self.debugActions[0] ):

-                self.debugActions[0]( instring, loc, self )

-            if callPreParse and self.callPreparse:

-                preloc = self.preParse( instring, loc )

-            else:

-                preloc = loc

-            tokensStart = preloc

-            try:

-                try:

-                    loc,tokens = self.parseImpl( instring, preloc, doActions )

-                except IndexError:

-                    raise ParseException( instring, len(instring), self.errmsg, self )

-            except ParseBaseException as err:

-                #~ print ("Exception raised:", err)

-                if self.debugActions[2]:

-                    self.debugActions[2]( instring, tokensStart, self, err )

-                if self.failAction:

-                    self.failAction( instring, tokensStart, self, err )

-                raise

-        else:

-            if callPreParse and self.callPreparse:

-                preloc = self.preParse( instring, loc )

-            else:

-                preloc = loc

-            tokensStart = preloc

-            if self.mayIndexError or preloc >= len(instring):

-                try:

-                    loc,tokens = self.parseImpl( instring, preloc, doActions )

-                except IndexError:

-                    raise ParseException( instring, len(instring), self.errmsg, self )

-            else:

-                loc,tokens = self.parseImpl( instring, preloc, doActions )

-

-        tokens = self.postParse( instring, loc, tokens )

-

-        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )

-        if self.parseAction and (doActions or self.callDuringTry):

-            if debugging:

-                try:

-                    for fn in self.parseAction:

-                        tokens = fn( instring, tokensStart, retTokens )

-                        if tokens is not None:

-                            retTokens = ParseResults( tokens,

-                                                      self.resultsName,

-                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),

-                                                      modal=self.modalResults )

-                except ParseBaseException as err:

-                    #~ print "Exception raised in user parse action:", err

-                    if (self.debugActions[2] ):

-                        self.debugActions[2]( instring, tokensStart, self, err )

-                    raise

-            else:

-                for fn in self.parseAction:

-                    tokens = fn( instring, tokensStart, retTokens )

-                    if tokens is not None:

-                        retTokens = ParseResults( tokens,

-                                                  self.resultsName,

-                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),

-                                                  modal=self.modalResults )

-        if debugging:

-            #~ print ("Matched",self,"->",retTokens.asList())

-            if (self.debugActions[1] ):

-                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )

-

-        return loc, retTokens

-

-    def tryParse( self, instring, loc ):

-        try:

-            return self._parse( instring, loc, doActions=False )[0]

-        except ParseFatalException:

-            raise ParseException( instring, loc, self.errmsg, self)

-    

-    def canParseNext(self, instring, loc):

-        try:

-            self.tryParse(instring, loc)

-        except (ParseException, IndexError):

-            return False

-        else:

-            return True

-

-    class _UnboundedCache(object):

-        def __init__(self):

-            cache = {}

-            self.not_in_cache = not_in_cache = object()

-

-            def get(self, key):

-                return cache.get(key, not_in_cache)

-

-            def set(self, key, value):

-                cache[key] = value

-

-            def clear(self):

-                cache.clear()

-                

-            def cache_len(self):

-                return len(cache)

-

-            self.get = types.MethodType(get, self)

-            self.set = types.MethodType(set, self)

-            self.clear = types.MethodType(clear, self)

-            self.__len__ = types.MethodType(cache_len, self)

-

-    if _OrderedDict is not None:

-        class _FifoCache(object):

-            def __init__(self, size):

-                self.not_in_cache = not_in_cache = object()

-

-                cache = _OrderedDict()

-

-                def get(self, key):

-                    return cache.get(key, not_in_cache)

-

-                def set(self, key, value):

-                    cache[key] = value

-                    while len(cache) > size:

-                        try:

-                            cache.popitem(False)

-                        except KeyError:

-                            pass

-

-                def clear(self):

-                    cache.clear()

-

-                def cache_len(self):

-                    return len(cache)

-

-                self.get = types.MethodType(get, self)

-                self.set = types.MethodType(set, self)

-                self.clear = types.MethodType(clear, self)

-                self.__len__ = types.MethodType(cache_len, self)

-

-    else:

-        class _FifoCache(object):

-            def __init__(self, size):

-                self.not_in_cache = not_in_cache = object()

-

-                cache = {}

-                key_fifo = collections.deque([], size)

-

-                def get(self, key):

-                    return cache.get(key, not_in_cache)

-

-                def set(self, key, value):

-                    cache[key] = value

-                    while len(key_fifo) > size:

-                        cache.pop(key_fifo.popleft(), None)

-                    key_fifo.append(key)

-

-                def clear(self):

-                    cache.clear()

-                    key_fifo.clear()

-

-                def cache_len(self):

-                    return len(cache)

-

-                self.get = types.MethodType(get, self)

-                self.set = types.MethodType(set, self)

-                self.clear = types.MethodType(clear, self)

-                self.__len__ = types.MethodType(cache_len, self)

-

-    # argument cache for optimizing repeated calls when backtracking through recursive expressions

-    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail

-    packrat_cache_lock = RLock()

-    packrat_cache_stats = [0, 0]

-

-    # this method gets repeatedly called during backtracking with the same arguments -

-    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression

-    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):

-        HIT, MISS = 0, 1

-        lookup = (self, instring, loc, callPreParse, doActions)

-        with ParserElement.packrat_cache_lock:

-            cache = ParserElement.packrat_cache

-            value = cache.get(lookup)

-            if value is cache.not_in_cache:

-                ParserElement.packrat_cache_stats[MISS] += 1

-                try:

-                    value = self._parseNoCache(instring, loc, doActions, callPreParse)

-                except ParseBaseException as pe:

-                    # cache a copy of the exception, without the traceback

-                    cache.set(lookup, pe.__class__(*pe.args))

-                    raise

-                else:

-                    cache.set(lookup, (value[0], value[1].copy()))

-                    return value

-            else:

-                ParserElement.packrat_cache_stats[HIT] += 1

-                if isinstance(value, Exception):

-                    raise value

-                return (value[0], value[1].copy())

-

-    _parse = _parseNoCache

-

-    @staticmethod

-    def resetCache():

-        ParserElement.packrat_cache.clear()

-        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)

-

-    _packratEnabled = False

-    @staticmethod

-    def enablePackrat(cache_size_limit=128):

-        """Enables "packrat" parsing, which adds memoizing to the parsing logic.

-           Repeated parse attempts at the same string location (which happens

-           often in many complex grammars) can immediately return a cached value,

-           instead of re-executing parsing/validating code.  Memoizing is done of

-           both valid results and parsing exceptions.

-           

-           Parameters:

-            - cache_size_limit - (default=C{128}) - if an integer value is provided

-              will limit the size of the packrat cache; if None is passed, then

-              the cache size will be unbounded; if 0 is passed, the cache will

-              be effectively disabled.

-            

-           This speedup may break existing programs that use parse actions that

-           have side-effects.  For this reason, packrat parsing is disabled when

-           you first import pyparsing.  To activate the packrat feature, your

-           program must call the class method C{ParserElement.enablePackrat()}.  If

-           your program uses C{psyco} to "compile as you go", you must call

-           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,

-           Python will crash.  For best results, call C{enablePackrat()} immediately

-           after importing pyparsing.

-           

-           Example::

-               import pyparsing

-               pyparsing.ParserElement.enablePackrat()

-        """

-        if not ParserElement._packratEnabled:

-            ParserElement._packratEnabled = True

-            if cache_size_limit is None:

-                ParserElement.packrat_cache = ParserElement._UnboundedCache()

-            else:

-                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)

-            ParserElement._parse = ParserElement._parseCache

-

-    def parseString( self, instring, parseAll=False ):

-        """

-        Execute the parse expression with the given string.

-        This is the main interface to the client code, once the complete

-        expression has been built.

-

-        If you want the grammar to require that the entire input string be

-        successfully parsed, then set C{parseAll} to True (equivalent to ending

-        the grammar with C{L{StringEnd()}}).

-

-        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,

-        in order to report proper column numbers in parse actions.

-        If the input string contains tabs and

-        the grammar uses parse actions that use the C{loc} argument to index into the

-        string being parsed, you can ensure you have a consistent view of the input

-        string by:

-         - calling C{parseWithTabs} on your grammar before calling C{parseString}

-           (see L{I{parseWithTabs}<parseWithTabs>})

-         - define your parse action using the full C{(s,loc,toks)} signature, and

-           reference the input string using the parse action's C{s} argument

-         - explictly expand the tabs in your input string before calling

-           C{parseString}

-        

-        Example::

-            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']

-            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text

-        """

-        ParserElement.resetCache()

-        if not self.streamlined:

-            self.streamline()

-            #~ self.saveAsList = True

-        for e in self.ignoreExprs:

-            e.streamline()

-        if not self.keepTabs:

-            instring = instring.expandtabs()

-        try:

-            loc, tokens = self._parse( instring, 0 )

-            if parseAll:

-                loc = self.preParse( instring, loc )

-                se = Empty() + StringEnd()

-                se._parse( instring, loc )

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-        else:

-            return tokens

-

-    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):

-        """

-        Scan the input string for expression matches.  Each match will return the

-        matching tokens, start location, and end location.  May be called with optional

-        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If

-        C{overlap} is specified, then overlapping matches will be reported.

-

-        Note that the start and end locations are reported relative to the string

-        being parsed.  See L{I{parseString}<parseString>} for more information on parsing

-        strings with embedded tabs.

-

-        Example::

-            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"

-            print(source)

-            for tokens,start,end in Word(alphas).scanString(source):

-                print(' '*start + '^'*(end-start))

-                print(' '*start + tokens[0])

-        

-        prints::

-        

-            sldjf123lsdjjkf345sldkjf879lkjsfd987

-            ^^^^^

-            sldjf

-                    ^^^^^^^

-                    lsdjjkf

-                              ^^^^^^

-                              sldkjf

-                                       ^^^^^^

-                                       lkjsfd

-        """

-        if not self.streamlined:

-            self.streamline()

-        for e in self.ignoreExprs:

-            e.streamline()

-

-        if not self.keepTabs:

-            instring = _ustr(instring).expandtabs()

-        instrlen = len(instring)

-        loc = 0

-        preparseFn = self.preParse

-        parseFn = self._parse

-        ParserElement.resetCache()

-        matches = 0

-        try:

-            while loc <= instrlen and matches < maxMatches:

-                try:

-                    preloc = preparseFn( instring, loc )

-                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )

-                except ParseException:

-                    loc = preloc+1

-                else:

-                    if nextLoc > loc:

-                        matches += 1

-                        yield tokens, preloc, nextLoc

-                        if overlap:

-                            nextloc = preparseFn( instring, loc )

-                            if nextloc > loc:

-                                loc = nextLoc

-                            else:

-                                loc += 1

-                        else:

-                            loc = nextLoc

-                    else:

-                        loc = preloc+1

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def transformString( self, instring ):

-        """

-        Extension to C{L{scanString}}, to modify matching text with modified tokens that may

-        be returned from a parse action.  To use C{transformString}, define a grammar and

-        attach a parse action to it that modifies the returned token list.

-        Invoking C{transformString()} on a target string will then scan for matches,

-        and replace the matched text patterns according to the logic in the parse

-        action.  C{transformString()} returns the resulting transformed string.

-        

-        Example::

-            wd = Word(alphas)

-            wd.setParseAction(lambda toks: toks[0].title())

-            

-            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))

-        Prints::

-            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.

-        """

-        out = []

-        lastE = 0

-        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to

-        # keep string locs straight between transformString and scanString

-        self.keepTabs = True

-        try:

-            for t,s,e in self.scanString( instring ):

-                out.append( instring[lastE:s] )

-                if t:

-                    if isinstance(t,ParseResults):

-                        out += t.asList()

-                    elif isinstance(t,list):

-                        out += t

-                    else:

-                        out.append(t)

-                lastE = e

-            out.append(instring[lastE:])

-            out = [o for o in out if o]

-            return "".join(map(_ustr,_flatten(out)))

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def searchString( self, instring, maxMatches=_MAX_INT ):

-        """

-        Another extension to C{L{scanString}}, simplifying the access to the tokens found

-        to match the given parse expression.  May be called with optional

-        C{maxMatches} argument, to clip searching after 'n' matches are found.

-        

-        Example::

-            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters

-            cap_word = Word(alphas.upper(), alphas.lower())

-            

-            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))

-

-            # the sum() builtin can be used to merge results into a single ParseResults object

-            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))

-        prints::

-            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]

-            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']

-        """

-        try:

-            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):

-        """

-        Generator method to split a string using the given expression as a separator.

-        May be called with optional C{maxsplit} argument, to limit the number of splits;

-        and the optional C{includeSeparators} argument (default=C{False}), if the separating

-        matching text should be included in the split results.

-        

-        Example::        

-            punc = oneOf(list(".,;:/-!?"))

-            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))

-        prints::

-            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']

-        """

-        splits = 0

-        last = 0

-        for t,s,e in self.scanString(instring, maxMatches=maxsplit):

-            yield instring[last:s]

-            if includeSeparators:

-                yield t[0]

-            last = e

-        yield instring[last:]

-

-    def __add__(self, other ):

-        """

-        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement

-        converts them to L{Literal}s by default.

-        

-        Example::

-            greet = Word(alphas) + "," + Word(alphas) + "!"

-            hello = "Hello, World!"

-            print (hello, "->", greet.parseString(hello))

-        Prints::

-            Hello, World! -> ['Hello', ',', 'World', '!']

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return And( [ self, other ] )

-

-    def __radd__(self, other ):

-        """

-        Implementation of + operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other + self

-

-    def __sub__(self, other):

-        """

-        Implementation of - operator, returns C{L{And}} with error stop

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return self + And._ErrorStop() + other

-

-    def __rsub__(self, other ):

-        """

-        Implementation of - operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other - self

-

-    def __mul__(self,other):

-        """

-        Implementation of * operator, allows use of C{expr * 3} in place of

-        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer

-        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples

-        may also include C{None} as in:

-         - C{expr*(n,None)} or C{expr*(n,)} is equivalent

-              to C{expr*n + L{ZeroOrMore}(expr)}

-              (read as "at least n instances of C{expr}")

-         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}

-              (read as "0 to n instances of C{expr}")

-         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}

-         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}

-

-        Note that C{expr*(None,n)} does not raise an exception if

-        more than n exprs exist in the input stream; that is,

-        C{expr*(None,n)} does not enforce a maximum number of expr

-        occurrences.  If this behavior is desired, then write

-        C{expr*(None,n) + ~expr}

-        """

-        if isinstance(other,int):

-            minElements, optElements = other,0

-        elif isinstance(other,tuple):

-            other = (other + (None, None))[:2]

-            if other[0] is None:

-                other = (0, other[1])

-            if isinstance(other[0],int) and other[1] is None:

-                if other[0] == 0:

-                    return ZeroOrMore(self)

-                if other[0] == 1:

-                    return OneOrMore(self)

-                else:

-                    return self*other[0] + ZeroOrMore(self)

-            elif isinstance(other[0],int) and isinstance(other[1],int):

-                minElements, optElements = other

-                optElements -= minElements

-            else:

-                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))

-        else:

-            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))

-

-        if minElements < 0:

-            raise ValueError("cannot multiply ParserElement by negative value")

-        if optElements < 0:

-            raise ValueError("second tuple value must be greater or equal to first tuple value")

-        if minElements == optElements == 0:

-            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")

-

-        if (optElements):

-            def makeOptionalList(n):

-                if n>1:

-                    return Optional(self + makeOptionalList(n-1))

-                else:

-                    return Optional(self)

-            if minElements:

-                if minElements == 1:

-                    ret = self + makeOptionalList(optElements)

-                else:

-                    ret = And([self]*minElements) + makeOptionalList(optElements)

-            else:

-                ret = makeOptionalList(optElements)

-        else:

-            if minElements == 1:

-                ret = self

-            else:

-                ret = And([self]*minElements)

-        return ret

-

-    def __rmul__(self, other):

-        return self.__mul__(other)

-

-    def __or__(self, other ):

-        """

-        Implementation of | operator - returns C{L{MatchFirst}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return MatchFirst( [ self, other ] )

-

-    def __ror__(self, other ):

-        """

-        Implementation of | operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other | self

-

-    def __xor__(self, other ):

-        """

-        Implementation of ^ operator - returns C{L{Or}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return Or( [ self, other ] )

-

-    def __rxor__(self, other ):

-        """

-        Implementation of ^ operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other ^ self

-

-    def __and__(self, other ):

-        """

-        Implementation of & operator - returns C{L{Each}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return Each( [ self, other ] )

-

-    def __rand__(self, other ):

-        """

-        Implementation of & operator when left operand is not a C{L{ParserElement}}

-        """

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        if not isinstance( other, ParserElement ):

-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),

-                    SyntaxWarning, stacklevel=2)

-            return None

-        return other & self

-

-    def __invert__( self ):

-        """

-        Implementation of ~ operator - returns C{L{NotAny}}

-        """

-        return NotAny( self )

-

-    def __call__(self, name=None):

-        """

-        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.

-        

-        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be

-        passed as C{True}.

-           

-        If C{name} is omitted, same as calling C{L{copy}}.

-

-        Example::

-            # these are equivalent

-            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")

-            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             

-        """

-        if name is not None:

-            return self.setResultsName(name)

-        else:

-            return self.copy()

-

-    def suppress( self ):

-        """

-        Suppresses the output of this C{ParserElement}; useful to keep punctuation from

-        cluttering up returned output.

-        """

-        return Suppress( self )

-

-    def leaveWhitespace( self ):

-        """

-        Disables the skipping of whitespace before matching the characters in the

-        C{ParserElement}'s defined pattern.  This is normally only used internally by

-        the pyparsing module, but may be needed in some whitespace-sensitive grammars.

-        """

-        self.skipWhitespace = False

-        return self

-

-    def setWhitespaceChars( self, chars ):

-        """

-        Overrides the default whitespace chars

-        """

-        self.skipWhitespace = True

-        self.whiteChars = chars

-        self.copyDefaultWhiteChars = False

-        return self

-

-    def parseWithTabs( self ):

-        """

-        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string.

-        Must be called before C{parseString} when the input grammar contains elements that

-        match C{<TAB>} characters.

-        """

-        self.keepTabs = True

-        return self

-

-    def ignore( self, other ):

-        """

-        Define expression to be ignored (e.g., comments) while doing pattern

-        matching; may be called repeatedly, to define multiple comment or other

-        ignorable patterns.

-        

-        Example::

-            patt = OneOrMore(Word(alphas))

-            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']

-            

-            patt.ignore(cStyleComment)

-            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']

-        """

-        if isinstance(other, basestring):

-            other = Suppress(other)

-

-        if isinstance( other, Suppress ):

-            if other not in self.ignoreExprs:

-                self.ignoreExprs.append(other)

-        else:

-            self.ignoreExprs.append( Suppress( other.copy() ) )

-        return self

-

-    def setDebugActions( self, startAction, successAction, exceptionAction ):

-        """

-        Enable display of debugging messages while doing pattern matching.

-        """

-        self.debugActions = (startAction or _defaultStartDebugAction,

-                             successAction or _defaultSuccessDebugAction,

-                             exceptionAction or _defaultExceptionDebugAction)

-        self.debug = True

-        return self

-

-    def setDebug( self, flag=True ):

-        """

-        Enable display of debugging messages while doing pattern matching.

-        Set C{flag} to True to enable, False to disable.

-

-        Example::

-            wd = Word(alphas).setName("alphaword")

-            integer = Word(nums).setName("numword")

-            term = wd | integer

-            

-            # turn on debugging for wd

-            wd.setDebug()

-

-            OneOrMore(term).parseString("abc 123 xyz 890")

-        

-        prints::

-            Match alphaword at loc 0(1,1)

-            Matched alphaword -> ['abc']

-            Match alphaword at loc 3(1,4)

-            Exception raised:Expected alphaword (at char 4), (line:1, col:5)

-            Match alphaword at loc 7(1,8)

-            Matched alphaword -> ['xyz']

-            Match alphaword at loc 11(1,12)

-            Exception raised:Expected alphaword (at char 12), (line:1, col:13)

-            Match alphaword at loc 15(1,16)

-            Exception raised:Expected alphaword (at char 15), (line:1, col:16)

-

-        The output shown is that produced by the default debug actions - custom debug actions can be

-        specified using L{setDebugActions}. Prior to attempting

-        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"}

-        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}

-        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,

-        which makes debugging and exception messages easier to understand - for instance, the default

-        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.

-        """

-        if flag:

-            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )

-        else:

-            self.debug = False

-        return self

-

-    def __str__( self ):

-        return self.name

-

-    def __repr__( self ):

-        return _ustr(self)

-

-    def streamline( self ):

-        self.streamlined = True

-        self.strRepr = None

-        return self

-

-    def checkRecursion( self, parseElementList ):

-        pass

-

-    def validate( self, validateTrace=[] ):

-        """

-        Check defined expressions for valid structure, check for infinite recursive definitions.

-        """

-        self.checkRecursion( [] )

-

-    def parseFile( self, file_or_filename, parseAll=False ):

-        """

-        Execute the parse expression on the given file or filename.

-        If a filename is specified (instead of a file object),

-        the entire file is opened, read, and closed before parsing.

-        """

-        try:

-            file_contents = file_or_filename.read()

-        except AttributeError:

-            with open(file_or_filename, "r") as f:

-                file_contents = f.read()

-        try:

-            return self.parseString(file_contents, parseAll)

-        except ParseBaseException as exc:

-            if ParserElement.verbose_stacktrace:

-                raise

-            else:

-                # catch and re-raise exception from here, clears out pyparsing internal stack trace

-                raise exc

-

-    def __eq__(self,other):

-        if isinstance(other, ParserElement):

-            return self is other or vars(self) == vars(other)

-        elif isinstance(other, basestring):

-            return self.matches(other)

-        else:

-            return super(ParserElement,self)==other

-

-    def __ne__(self,other):

-        return not (self == other)

-

-    def __hash__(self):

-        return hash(id(self))

-

-    def __req__(self,other):

-        return self == other

-

-    def __rne__(self,other):

-        return not (self == other)

-

-    def matches(self, testString, parseAll=True):

-        """

-        Method for quick testing of a parser against a test string. Good for simple 

-        inline microtests of sub expressions while building up larger parser.

-           

-        Parameters:

-         - testString - to test against this expression for a match

-         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests

-            

-        Example::

-            expr = Word(nums)

-            assert expr.matches("100")

-        """

-        try:

-            self.parseString(_ustr(testString), parseAll=parseAll)

-            return True

-        except ParseBaseException:

-            return False

-                

-    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):

-        """

-        Execute the parse expression on a series of test strings, showing each

-        test, the parsed results or where the parse failed. Quick and easy way to

-        run a parse expression against a list of sample strings.

-           

-        Parameters:

-         - tests - a list of separate test strings, or a multiline string of test strings

-         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           

-         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 

-              string; pass None to disable comment filtering

-         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;

-              if False, only dump nested list

-         - printResults - (default=C{True}) prints test output to stdout

-         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing

-

-        Returns: a (success, results) tuple, where success indicates that all tests succeeded

-        (or failed if C{failureTests} is True), and the results contain a list of lines of each 

-        test's output

-        

-        Example::

-            number_expr = pyparsing_common.number.copy()

-

-            result = number_expr.runTests('''

-                # unsigned integer

-                100

-                # negative integer

-                -100

-                # float with scientific notation

-                6.02e23

-                # integer with scientific notation

-                1e-12

-                ''')

-            print("Success" if result[0] else "Failed!")

-

-            result = number_expr.runTests('''

-                # stray character

-                100Z

-                # missing leading digit before '.'

-                -.100

-                # too many '.'

-                3.14.159

-                ''', failureTests=True)

-            print("Success" if result[0] else "Failed!")

-        prints::

-            # unsigned integer

-            100

-            [100]

-

-            # negative integer

-            -100

-            [-100]

-

-            # float with scientific notation

-            6.02e23

-            [6.02e+23]

-

-            # integer with scientific notation

-            1e-12

-            [1e-12]

-

-            Success

-            

-            # stray character

-            100Z

-               ^

-            FAIL: Expected end of text (at char 3), (line:1, col:4)

-

-            # missing leading digit before '.'

-            -.100

-            ^

-            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)

-

-            # too many '.'

-            3.14.159

-                ^

-            FAIL: Expected end of text (at char 4), (line:1, col:5)

-

-            Success

-

-        Each test string must be on a single line. If you want to test a string that spans multiple

-        lines, create a test like this::

-

-            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")

-        

-        (Note that this is a raw string literal, you must include the leading 'r'.)

-        """

-        if isinstance(tests, basestring):

-            tests = list(map(str.strip, tests.rstrip().splitlines()))

-        if isinstance(comment, basestring):

-            comment = Literal(comment)

-        allResults = []

-        comments = []

-        success = True

-        for t in tests:

-            if comment is not None and comment.matches(t, False) or comments and not t:

-                comments.append(t)

-                continue

-            if not t:

-                continue

-            out = ['\n'.join(comments), t]

-            comments = []

-            try:

-                t = t.replace(r'\n','\n')

-                result = self.parseString(t, parseAll=parseAll)

-                out.append(result.dump(full=fullDump))

-                success = success and not failureTests

-            except ParseBaseException as pe:

-                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""

-                if '\n' in t:

-                    out.append(line(pe.loc, t))

-                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)

-                else:

-                    out.append(' '*pe.loc + '^' + fatal)

-                out.append("FAIL: " + str(pe))

-                success = success and failureTests

-                result = pe

-            except Exception as exc:

-                out.append("FAIL-EXCEPTION: " + str(exc))

-                success = success and failureTests

-                result = exc

-

-            if printResults:

-                if fullDump:

-                    out.append('')

-                print('\n'.join(out))

-

-            allResults.append((t, result))

-        

-        return success, allResults

-

-        

-class Token(ParserElement):

-    """

-    Abstract C{ParserElement} subclass, for defining atomic matching patterns.

-    """

-    def __init__( self ):

-        super(Token,self).__init__( savelist=False )

-

-

-class Empty(Token):

-    """

-    An empty token, will always match.

-    """

-    def __init__( self ):

-        super(Empty,self).__init__()

-        self.name = "Empty"

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-

-

-class NoMatch(Token):

-    """

-    A token that will never match.

-    """

-    def __init__( self ):

-        super(NoMatch,self).__init__()

-        self.name = "NoMatch"

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-        self.errmsg = "Unmatchable token"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        raise ParseException(instring, loc, self.errmsg, self)

-

-

-class Literal(Token):

-    """

-    Token to exactly match a specified string.

-    

-    Example::

-        Literal('blah').parseString('blah')  # -> ['blah']

-        Literal('blah').parseString('blahfooblah')  # -> ['blah']

-        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"

-    

-    For case-insensitive matching, use L{CaselessLiteral}.

-    

-    For keyword matching (force word break before and after the matched string),

-    use L{Keyword} or L{CaselessKeyword}.

-    """

-    def __init__( self, matchString ):

-        super(Literal,self).__init__()

-        self.match = matchString

-        self.matchLen = len(matchString)

-        try:

-            self.firstMatchChar = matchString[0]

-        except IndexError:

-            warnings.warn("null string passed to Literal; use Empty() instead",

-                            SyntaxWarning, stacklevel=2)

-            self.__class__ = Empty

-        self.name = '"%s"' % _ustr(self.match)

-        self.errmsg = "Expected " + self.name

-        self.mayReturnEmpty = False

-        self.mayIndexError = False

-

-    # Performance tuning: this routine gets called a *lot*

-    # if this is a single character match string  and the first character matches,

-    # short-circuit as quickly as possible, and avoid calling startswith

-    #~ @profile

-    def parseImpl( self, instring, loc, doActions=True ):

-        if (instring[loc] == self.firstMatchChar and

-            (self.matchLen==1 or instring.startswith(self.match,loc)) ):

-            return loc+self.matchLen, self.match

-        raise ParseException(instring, loc, self.errmsg, self)

-_L = Literal

-ParserElement._literalStringClass = Literal

-

-class Keyword(Token):

-    """

-    Token to exactly match a specified string as a keyword, that is, it must be

-    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:

-     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.

-     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}

-    Accepts two optional constructor arguments in addition to the keyword string:

-     - C{identChars} is a string of characters that would be valid identifier characters,

-          defaulting to all alphanumerics + "_" and "$"

-     - C{caseless} allows case-insensitive matching, default is C{False}.

-       

-    Example::

-        Keyword("start").parseString("start")  # -> ['start']

-        Keyword("start").parseString("starting")  # -> Exception

-

-    For case-insensitive matching, use L{CaselessKeyword}.

-    """

-    DEFAULT_KEYWORD_CHARS = alphanums+"_$"

-

-    def __init__( self, matchString, identChars=None, caseless=False ):

-        super(Keyword,self).__init__()

-        if identChars is None:

-            identChars = Keyword.DEFAULT_KEYWORD_CHARS

-        self.match = matchString

-        self.matchLen = len(matchString)

-        try:

-            self.firstMatchChar = matchString[0]

-        except IndexError:

-            warnings.warn("null string passed to Keyword; use Empty() instead",

-                            SyntaxWarning, stacklevel=2)

-        self.name = '"%s"' % self.match

-        self.errmsg = "Expected " + self.name

-        self.mayReturnEmpty = False

-        self.mayIndexError = False

-        self.caseless = caseless

-        if caseless:

-            self.caselessmatch = matchString.upper()

-            identChars = identChars.upper()

-        self.identChars = set(identChars)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.caseless:

-            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and

-                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and

-                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):

-                return loc+self.matchLen, self.match

-        else:

-            if (instring[loc] == self.firstMatchChar and

-                (self.matchLen==1 or instring.startswith(self.match,loc)) and

-                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and

-                (loc == 0 or instring[loc-1] not in self.identChars) ):

-                return loc+self.matchLen, self.match

-        raise ParseException(instring, loc, self.errmsg, self)

-

-    def copy(self):

-        c = super(Keyword,self).copy()

-        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS

-        return c

-

-    @staticmethod

-    def setDefaultKeywordChars( chars ):

-        """Overrides the default Keyword chars

-        """

-        Keyword.DEFAULT_KEYWORD_CHARS = chars

-

-class CaselessLiteral(Literal):

-    """

-    Token to match a specified string, ignoring case of letters.

-    Note: the matched results will always be in the case of the given

-    match string, NOT the case of the input text.

-

-    Example::

-        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']

-        

-    (Contrast with example for L{CaselessKeyword}.)

-    """

-    def __init__( self, matchString ):

-        super(CaselessLiteral,self).__init__( matchString.upper() )

-        # Preserve the defining literal.

-        self.returnString = matchString

-        self.name = "'%s'" % self.returnString

-        self.errmsg = "Expected " + self.name

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if instring[ loc:loc+self.matchLen ].upper() == self.match:

-            return loc+self.matchLen, self.returnString

-        raise ParseException(instring, loc, self.errmsg, self)

-

-class CaselessKeyword(Keyword):

-    """

-    Caseless version of L{Keyword}.

-

-    Example::

-        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']

-        

-    (Contrast with example for L{CaselessLiteral}.)

-    """

-    def __init__( self, matchString, identChars=None ):

-        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and

-             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):

-            return loc+self.matchLen, self.match

-        raise ParseException(instring, loc, self.errmsg, self)

-

-class CloseMatch(Token):

-    """

-    A variation on L{Literal} which matches "close" matches, that is, 

-    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:

-     - C{match_string} - string to be matched

-     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match

-    

-    The results from a successful parse will contain the matched text from the input string and the following named results:

-     - C{mismatches} - a list of the positions within the match_string where mismatches were found

-     - C{original} - the original match_string used to compare against the input string

-    

-    If C{mismatches} is an empty list, then the match was an exact match.

-    

-    Example::

-        patt = CloseMatch("ATCATCGAATGGA")

-        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})

-        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)

-

-        # exact match

-        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})

-

-        # close match allowing up to 2 mismatches

-        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)

-        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})

-    """

-    def __init__(self, match_string, maxMismatches=1):

-        super(CloseMatch,self).__init__()

-        self.name = match_string

-        self.match_string = match_string

-        self.maxMismatches = maxMismatches

-        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)

-        self.mayIndexError = False

-        self.mayReturnEmpty = False

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        start = loc

-        instrlen = len(instring)

-        maxloc = start + len(self.match_string)

-

-        if maxloc <= instrlen:

-            match_string = self.match_string

-            match_stringloc = 0

-            mismatches = []

-            maxMismatches = self.maxMismatches

-

-            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):

-                src,mat = s_m

-                if src != mat:

-                    mismatches.append(match_stringloc)

-                    if len(mismatches) > maxMismatches:

-                        break

-            else:

-                loc = match_stringloc + 1

-                results = ParseResults([instring[start:loc]])

-                results['original'] = self.match_string

-                results['mismatches'] = mismatches

-                return loc, results

-

-        raise ParseException(instring, loc, self.errmsg, self)

-

-

-class Word(Token):

-    """

-    Token for matching words composed of allowed character sets.

-    Defined with string containing all allowed initial characters,

-    an optional string containing allowed body characters (if omitted,

-    defaults to the initial character set), and an optional minimum,

-    maximum, and/or exact length.  The default value for C{min} is 1 (a

-    minimum value < 1 is not valid); the default values for C{max} and C{exact}

-    are 0, meaning no maximum or exact length restriction. An optional

-    C{excludeChars} parameter can list characters that might be found in 

-    the input C{bodyChars} string; useful to define a word of all printables

-    except for one or two characters, for instance.

-    

-    L{srange} is useful for defining custom character set strings for defining 

-    C{Word} expressions, using range notation from regular expression character sets.

-    

-    A common mistake is to use C{Word} to match a specific literal string, as in 

-    C{Word("Address")}. Remember that C{Word} uses the string argument to define

-    I{sets} of matchable characters. This expression would match "Add", "AAA",

-    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.

-    To match an exact literal string, use L{Literal} or L{Keyword}.

-

-    pyparsing includes helper strings for building Words:

-     - L{alphas}

-     - L{nums}

-     - L{alphanums}

-     - L{hexnums}

-     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)

-     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)

-     - L{printables} (any non-whitespace character)

-

-    Example::

-        # a word composed of digits

-        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))

-        

-        # a word with a leading capital, and zero or more lowercase

-        capital_word = Word(alphas.upper(), alphas.lower())

-

-        # hostnames are alphanumeric, with leading alpha, and '-'

-        hostname = Word(alphas, alphanums+'-')

-        

-        # roman numeral (not a strict parser, accepts invalid mix of characters)

-        roman = Word("IVXLCDM")

-        

-        # any string of non-whitespace characters, except for ','

-        csv_value = Word(printables, excludeChars=",")

-    """

-    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):

-        super(Word,self).__init__()

-        if excludeChars:

-            initChars = ''.join(c for c in initChars if c not in excludeChars)

-            if bodyChars:

-                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)

-        self.initCharsOrig = initChars

-        self.initChars = set(initChars)

-        if bodyChars :

-            self.bodyCharsOrig = bodyChars

-            self.bodyChars = set(bodyChars)

-        else:

-            self.bodyCharsOrig = initChars

-            self.bodyChars = set(initChars)

-

-        self.maxSpecified = max > 0

-

-        if min < 1:

-            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")

-

-        self.minLen = min

-

-        if max > 0:

-            self.maxLen = max

-        else:

-            self.maxLen = _MAX_INT

-

-        if exact > 0:

-            self.maxLen = exact

-            self.minLen = exact

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayIndexError = False

-        self.asKeyword = asKeyword

-

-        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):

-            if self.bodyCharsOrig == self.initCharsOrig:

-                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)

-            elif len(self.initCharsOrig) == 1:

-                self.reString = "%s[%s]*" % \

-                                      (re.escape(self.initCharsOrig),

-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)

-            else:

-                self.reString = "[%s][%s]*" % \

-                                      (_escapeRegexRangeChars(self.initCharsOrig),

-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)

-            if self.asKeyword:

-                self.reString = r"\b"+self.reString+r"\b"

-            try:

-                self.re = re.compile( self.reString )

-            except Exception:

-                self.re = None

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.re:

-            result = self.re.match(instring,loc)

-            if not result:

-                raise ParseException(instring, loc, self.errmsg, self)

-

-            loc = result.end()

-            return loc, result.group()

-

-        if not(instring[ loc ] in self.initChars):

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        start = loc

-        loc += 1

-        instrlen = len(instring)

-        bodychars = self.bodyChars

-        maxloc = start + self.maxLen

-        maxloc = min( maxloc, instrlen )

-        while loc < maxloc and instring[loc] in bodychars:

-            loc += 1

-

-        throwException = False

-        if loc - start < self.minLen:

-            throwException = True

-        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:

-            throwException = True

-        if self.asKeyword:

-            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):

-                throwException = True

-

-        if throwException:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        return loc, instring[start:loc]

-

-    def __str__( self ):

-        try:

-            return super(Word,self).__str__()

-        except Exception:

-            pass

-

-

-        if self.strRepr is None:

-

-            def charsAsStr(s):

-                if len(s)>4:

-                    return s[:4]+"..."

-                else:

-                    return s

-

-            if ( self.initCharsOrig != self.bodyCharsOrig ):

-                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )

-            else:

-                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)

-

-        return self.strRepr

-

-

-class Regex(Token):

-    r"""

-    Token for matching strings that match a given regular expression.

-    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.

-    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as 

-    named parse results.

-

-    Example::

-        realnum = Regex(r"[+-]?\d+\.\d*")

-        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')

-        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression

-        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")

-    """

-    compiledREtype = type(re.compile("[A-Z]"))

-    def __init__( self, pattern, flags=0):

-        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""

-        super(Regex,self).__init__()

-

-        if isinstance(pattern, basestring):

-            if not pattern:

-                warnings.warn("null string passed to Regex; use Empty() instead",

-                        SyntaxWarning, stacklevel=2)

-

-            self.pattern = pattern

-            self.flags = flags

-

-            try:

-                self.re = re.compile(self.pattern, self.flags)

-                self.reString = self.pattern

-            except sre_constants.error:

-                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,

-                    SyntaxWarning, stacklevel=2)

-                raise

-

-        elif isinstance(pattern, Regex.compiledREtype):

-            self.re = pattern

-            self.pattern = \

-            self.reString = str(pattern)

-            self.flags = flags

-            

-        else:

-            raise ValueError("Regex may only be constructed with a string or a compiled RE object")

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayIndexError = False

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        result = self.re.match(instring,loc)

-        if not result:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        loc = result.end()

-        d = result.groupdict()

-        ret = ParseResults(result.group())

-        if d:

-            for k in d:

-                ret[k] = d[k]

-        return loc,ret

-

-    def __str__( self ):

-        try:

-            return super(Regex,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            self.strRepr = "Re:(%s)" % repr(self.pattern)

-

-        return self.strRepr

-

-

-class QuotedString(Token):

-    r"""

-    Token for matching strings that are delimited by quoting characters.

-    

-    Defined with the following parameters:

-        - quoteChar - string of one or more characters defining the quote delimiting string

-        - escChar - character to escape quotes, typically backslash (default=C{None})

-        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})

-        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})

-        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})

-        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)

-        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})

-

-    Example::

-        qs = QuotedString('"')

-        print(qs.searchString('lsjdf "This is the quote" sldjf'))

-        complex_qs = QuotedString('{{', endQuoteChar='}}')

-        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))

-        sql_qs = QuotedString('"', escQuote='""')

-        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))

-    prints::

-        [['This is the quote']]

-        [['This is the "quote"']]

-        [['This is the quote with "embedded" quotes']]

-    """

-    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):

-        super(QuotedString,self).__init__()

-

-        # remove white space from quote chars - wont work anyway

-        quoteChar = quoteChar.strip()

-        if not quoteChar:

-            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)

-            raise SyntaxError()

-

-        if endQuoteChar is None:

-            endQuoteChar = quoteChar

-        else:

-            endQuoteChar = endQuoteChar.strip()

-            if not endQuoteChar:

-                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)

-                raise SyntaxError()

-

-        self.quoteChar = quoteChar

-        self.quoteCharLen = len(quoteChar)

-        self.firstQuoteChar = quoteChar[0]

-        self.endQuoteChar = endQuoteChar

-        self.endQuoteCharLen = len(endQuoteChar)

-        self.escChar = escChar

-        self.escQuote = escQuote

-        self.unquoteResults = unquoteResults

-        self.convertWhitespaceEscapes = convertWhitespaceEscapes

-

-        if multiline:

-            self.flags = re.MULTILINE | re.DOTALL

-            self.pattern = r'%s(?:[^%s%s]' % \

-                ( re.escape(self.quoteChar),

-                  _escapeRegexRangeChars(self.endQuoteChar[0]),

-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )

-        else:

-            self.flags = 0

-            self.pattern = r'%s(?:[^%s\n\r%s]' % \

-                ( re.escape(self.quoteChar),

-                  _escapeRegexRangeChars(self.endQuoteChar[0]),

-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )

-        if len(self.endQuoteChar) > 1:

-            self.pattern += (

-                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),

-                                               _escapeRegexRangeChars(self.endQuoteChar[i]))

-                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'

-                )

-        if escQuote:

-            self.pattern += (r'|(?:%s)' % re.escape(escQuote))

-        if escChar:

-            self.pattern += (r'|(?:%s.)' % re.escape(escChar))

-            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"

-        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))

-

-        try:

-            self.re = re.compile(self.pattern, self.flags)

-            self.reString = self.pattern

-        except sre_constants.error:

-            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,

-                SyntaxWarning, stacklevel=2)

-            raise

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayIndexError = False

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None

-        if not result:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        loc = result.end()

-        ret = result.group()

-

-        if self.unquoteResults:

-

-            # strip off quotes

-            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]

-

-            if isinstance(ret,basestring):

-                # replace escaped whitespace

-                if '\\' in ret and self.convertWhitespaceEscapes:

-                    ws_map = {

-                        r'\t' : '\t',

-                        r'\n' : '\n',

-                        r'\f' : '\f',

-                        r'\r' : '\r',

-                    }

-                    for wslit,wschar in ws_map.items():

-                        ret = ret.replace(wslit, wschar)

-

-                # replace escaped characters

-                if self.escChar:

-                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)

-

-                # replace escaped quotes

-                if self.escQuote:

-                    ret = ret.replace(self.escQuote, self.endQuoteChar)

-

-        return loc, ret

-

-    def __str__( self ):

-        try:

-            return super(QuotedString,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)

-

-        return self.strRepr

-

-

-class CharsNotIn(Token):

-    """

-    Token for matching words composed of characters I{not} in a given set (will

-    include whitespace in matched characters if not listed in the provided exclusion set - see example).

-    Defined with string containing all disallowed characters, and an optional

-    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a

-    minimum value < 1 is not valid); the default values for C{max} and C{exact}

-    are 0, meaning no maximum or exact length restriction.

-

-    Example::

-        # define a comma-separated-value as anything that is not a ','

-        csv_value = CharsNotIn(',')

-        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))

-    prints::

-        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']

-    """

-    def __init__( self, notChars, min=1, max=0, exact=0 ):

-        super(CharsNotIn,self).__init__()

-        self.skipWhitespace = False

-        self.notChars = notChars

-

-        if min < 1:

-            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")

-

-        self.minLen = min

-

-        if max > 0:

-            self.maxLen = max

-        else:

-            self.maxLen = _MAX_INT

-

-        if exact > 0:

-            self.maxLen = exact

-            self.minLen = exact

-

-        self.name = _ustr(self)

-        self.errmsg = "Expected " + self.name

-        self.mayReturnEmpty = ( self.minLen == 0 )

-        self.mayIndexError = False

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if instring[loc] in self.notChars:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        start = loc

-        loc += 1

-        notchars = self.notChars

-        maxlen = min( start+self.maxLen, len(instring) )

-        while loc < maxlen and \

-              (instring[loc] not in notchars):

-            loc += 1

-

-        if loc - start < self.minLen:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        return loc, instring[start:loc]

-

-    def __str__( self ):

-        try:

-            return super(CharsNotIn, self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            if len(self.notChars) > 4:

-                self.strRepr = "!W:(%s...)" % self.notChars[:4]

-            else:

-                self.strRepr = "!W:(%s)" % self.notChars

-

-        return self.strRepr

-

-class White(Token):

-    """

-    Special matching class for matching whitespace.  Normally, whitespace is ignored

-    by pyparsing grammars.  This class is included when some whitespace structures

-    are significant.  Define with a string containing the whitespace characters to be

-    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,

-    as defined for the C{L{Word}} class.

-    """

-    whiteStrs = {

-        " " : "<SPC>",

-        "\t": "<TAB>",

-        "\n": "<LF>",

-        "\r": "<CR>",

-        "\f": "<FF>",

-        }

-    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):

-        super(White,self).__init__()

-        self.matchWhite = ws

-        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )

-        #~ self.leaveWhitespace()

-        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))

-        self.mayReturnEmpty = True

-        self.errmsg = "Expected " + self.name

-

-        self.minLen = min

-

-        if max > 0:

-            self.maxLen = max

-        else:

-            self.maxLen = _MAX_INT

-

-        if exact > 0:

-            self.maxLen = exact

-            self.minLen = exact

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if not(instring[ loc ] in self.matchWhite):

-            raise ParseException(instring, loc, self.errmsg, self)

-        start = loc

-        loc += 1

-        maxloc = start + self.maxLen

-        maxloc = min( maxloc, len(instring) )

-        while loc < maxloc and instring[loc] in self.matchWhite:

-            loc += 1

-

-        if loc - start < self.minLen:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        return loc, instring[start:loc]

-

-

-class _PositionToken(Token):

-    def __init__( self ):

-        super(_PositionToken,self).__init__()

-        self.name=self.__class__.__name__

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-

-class GoToColumn(_PositionToken):

-    """

-    Token to advance to a specific column of input text; useful for tabular report scraping.

-    """

-    def __init__( self, colno ):

-        super(GoToColumn,self).__init__()

-        self.col = colno

-

-    def preParse( self, instring, loc ):

-        if col(loc,instring) != self.col:

-            instrlen = len(instring)

-            if self.ignoreExprs:

-                loc = self._skipIgnorables( instring, loc )

-            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :

-                loc += 1

-        return loc

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        thiscol = col( loc, instring )

-        if thiscol > self.col:

-            raise ParseException( instring, loc, "Text not in expected column", self )

-        newloc = loc + self.col - thiscol

-        ret = instring[ loc: newloc ]

-        return newloc, ret

-

-

-class LineStart(_PositionToken):

-    """

-    Matches if current position is at the beginning of a line within the parse string

-    

-    Example::

-    

-        test = '''\

-        AAA this line

-        AAA and this line

-          AAA but not this one

-        B AAA and definitely not this one

-        '''

-

-        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):

-            print(t)

-    

-    Prints::

-        ['AAA', ' this line']

-        ['AAA', ' and this line']    

-

-    """

-    def __init__( self ):

-        super(LineStart,self).__init__()

-        self.errmsg = "Expected start of line"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if col(loc, instring) == 1:

-            return loc, []

-        raise ParseException(instring, loc, self.errmsg, self)

-

-class LineEnd(_PositionToken):

-    """

-    Matches if current position is at the end of a line within the parse string

-    """

-    def __init__( self ):

-        super(LineEnd,self).__init__()

-        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )

-        self.errmsg = "Expected end of line"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if loc<len(instring):

-            if instring[loc] == "\n":

-                return loc+1, "\n"

-            else:

-                raise ParseException(instring, loc, self.errmsg, self)

-        elif loc == len(instring):

-            return loc+1, []

-        else:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-class StringStart(_PositionToken):

-    """

-    Matches if current position is at the beginning of the parse string

-    """

-    def __init__( self ):

-        super(StringStart,self).__init__()

-        self.errmsg = "Expected start of text"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if loc != 0:

-            # see if entire string up to here is just whitespace and ignoreables

-            if loc != self.preParse( instring, 0 ):

-                raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-class StringEnd(_PositionToken):

-    """

-    Matches if current position is at the end of the parse string

-    """

-    def __init__( self ):

-        super(StringEnd,self).__init__()

-        self.errmsg = "Expected end of text"

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if loc < len(instring):

-            raise ParseException(instring, loc, self.errmsg, self)

-        elif loc == len(instring):

-            return loc+1, []

-        elif loc > len(instring):

-            return loc, []

-        else:

-            raise ParseException(instring, loc, self.errmsg, self)

-

-class WordStart(_PositionToken):

-    """

-    Matches if the current position is at the beginning of a Word, and

-    is not preceded by any character in a given set of C{wordChars}

-    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,

-    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of

-    the string being parsed, or at the beginning of a line.

-    """

-    def __init__(self, wordChars = printables):

-        super(WordStart,self).__init__()

-        self.wordChars = set(wordChars)

-        self.errmsg = "Not at the start of a word"

-

-    def parseImpl(self, instring, loc, doActions=True ):

-        if loc != 0:

-            if (instring[loc-1] in self.wordChars or

-                instring[loc] not in self.wordChars):

-                raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-class WordEnd(_PositionToken):

-    """

-    Matches if the current position is at the end of a Word, and

-    is not followed by any character in a given set of C{wordChars}

-    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,

-    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of

-    the string being parsed, or at the end of a line.

-    """

-    def __init__(self, wordChars = printables):

-        super(WordEnd,self).__init__()

-        self.wordChars = set(wordChars)

-        self.skipWhitespace = False

-        self.errmsg = "Not at the end of a word"

-

-    def parseImpl(self, instring, loc, doActions=True ):

-        instrlen = len(instring)

-        if instrlen>0 and loc<instrlen:

-            if (instring[loc] in self.wordChars or

-                instring[loc-1] not in self.wordChars):

-                raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-

-class ParseExpression(ParserElement):

-    """

-    Abstract subclass of ParserElement, for combining and post-processing parsed tokens.

-    """

-    def __init__( self, exprs, savelist = False ):

-        super(ParseExpression,self).__init__(savelist)

-        if isinstance( exprs, _generatorType ):

-            exprs = list(exprs)

-

-        if isinstance( exprs, basestring ):

-            self.exprs = [ ParserElement._literalStringClass( exprs ) ]

-        elif isinstance( exprs, Iterable ):

-            exprs = list(exprs)

-            # if sequence of strings provided, wrap with Literal

-            if all(isinstance(expr, basestring) for expr in exprs):

-                exprs = map(ParserElement._literalStringClass, exprs)

-            self.exprs = list(exprs)

-        else:

-            try:

-                self.exprs = list( exprs )

-            except TypeError:

-                self.exprs = [ exprs ]

-        self.callPreparse = False

-

-    def __getitem__( self, i ):

-        return self.exprs[i]

-

-    def append( self, other ):

-        self.exprs.append( other )

-        self.strRepr = None

-        return self

-

-    def leaveWhitespace( self ):

-        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on

-           all contained expressions."""

-        self.skipWhitespace = False

-        self.exprs = [ e.copy() for e in self.exprs ]

-        for e in self.exprs:

-            e.leaveWhitespace()

-        return self

-

-    def ignore( self, other ):

-        if isinstance( other, Suppress ):

-            if other not in self.ignoreExprs:

-                super( ParseExpression, self).ignore( other )

-                for e in self.exprs:

-                    e.ignore( self.ignoreExprs[-1] )

-        else:

-            super( ParseExpression, self).ignore( other )

-            for e in self.exprs:

-                e.ignore( self.ignoreExprs[-1] )

-        return self

-

-    def __str__( self ):

-        try:

-            return super(ParseExpression,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None:

-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )

-        return self.strRepr

-

-    def streamline( self ):

-        super(ParseExpression,self).streamline()

-

-        for e in self.exprs:

-            e.streamline()

-

-        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )

-        # but only if there are no parse actions or resultsNames on the nested And's

-        # (likewise for Or's and MatchFirst's)

-        if ( len(self.exprs) == 2 ):

-            other = self.exprs[0]

-            if ( isinstance( other, self.__class__ ) and

-                  not(other.parseAction) and

-                  other.resultsName is None and

-                  not other.debug ):

-                self.exprs = other.exprs[:] + [ self.exprs[1] ]

-                self.strRepr = None

-                self.mayReturnEmpty |= other.mayReturnEmpty

-                self.mayIndexError  |= other.mayIndexError

-

-            other = self.exprs[-1]

-            if ( isinstance( other, self.__class__ ) and

-                  not(other.parseAction) and

-                  other.resultsName is None and

-                  not other.debug ):

-                self.exprs = self.exprs[:-1] + other.exprs[:]

-                self.strRepr = None

-                self.mayReturnEmpty |= other.mayReturnEmpty

-                self.mayIndexError  |= other.mayIndexError

-

-        self.errmsg = "Expected " + _ustr(self)

-        

-        return self

-

-    def setResultsName( self, name, listAllMatches=False ):

-        ret = super(ParseExpression,self).setResultsName(name,listAllMatches)

-        return ret

-

-    def validate( self, validateTrace=[] ):

-        tmp = validateTrace[:]+[self]

-        for e in self.exprs:

-            e.validate(tmp)

-        self.checkRecursion( [] )

-        

-    def copy(self):

-        ret = super(ParseExpression,self).copy()

-        ret.exprs = [e.copy() for e in self.exprs]

-        return ret

-

-class And(ParseExpression):

-    """

-    Requires all given C{ParseExpression}s to be found in the given order.

-    Expressions may be separated by whitespace.

-    May be constructed using the C{'+'} operator.

-    May also be constructed using the C{'-'} operator, which will suppress backtracking.

-

-    Example::

-        integer = Word(nums)

-        name_expr = OneOrMore(Word(alphas))

-

-        expr = And([integer("id"),name_expr("name"),integer("age")])

-        # more easily written as:

-        expr = integer("id") + name_expr("name") + integer("age")

-    """

-

-    class _ErrorStop(Empty):

-        def __init__(self, *args, **kwargs):

-            super(And._ErrorStop,self).__init__(*args, **kwargs)

-            self.name = '-'

-            self.leaveWhitespace()

-

-    def __init__( self, exprs, savelist = True ):

-        super(And,self).__init__(exprs, savelist)

-        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)

-        self.setWhitespaceChars( self.exprs[0].whiteChars )

-        self.skipWhitespace = self.exprs[0].skipWhitespace

-        self.callPreparse = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        # pass False as last arg to _parse for first element, since we already

-        # pre-parsed the string as part of our And pre-parsing

-        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )

-        errorStop = False

-        for e in self.exprs[1:]:

-            if isinstance(e, And._ErrorStop):

-                errorStop = True

-                continue

-            if errorStop:

-                try:

-                    loc, exprtokens = e._parse( instring, loc, doActions )

-                except ParseSyntaxException:

-                    raise

-                except ParseBaseException as pe:

-                    pe.__traceback__ = None

-                    raise ParseSyntaxException._from_exception(pe)

-                except IndexError:

-                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self)

-            else:

-                loc, exprtokens = e._parse( instring, loc, doActions )

-            if exprtokens or exprtokens.haskeys():

-                resultlist += exprtokens

-        return loc, resultlist

-

-    def __iadd__(self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        return self.append( other ) #And( [ self, other ] )

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-            if not e.mayReturnEmpty:

-                break

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-

-class Or(ParseExpression):

-    """

-    Requires that at least one C{ParseExpression} is found.

-    If two expressions match, the expression that matches the longest string will be used.

-    May be constructed using the C{'^'} operator.

-

-    Example::

-        # construct Or using '^' operator

-        

-        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))

-        print(number.searchString("123 3.1416 789"))

-    prints::

-        [['123'], ['3.1416'], ['789']]

-    """

-    def __init__( self, exprs, savelist = False ):

-        super(Or,self).__init__(exprs, savelist)

-        if self.exprs:

-            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)

-        else:

-            self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        maxExcLoc = -1

-        maxException = None

-        matches = []

-        for e in self.exprs:

-            try:

-                loc2 = e.tryParse( instring, loc )

-            except ParseException as err:

-                err.__traceback__ = None

-                if err.loc > maxExcLoc:

-                    maxException = err

-                    maxExcLoc = err.loc

-            except IndexError:

-                if len(instring) > maxExcLoc:

-                    maxException = ParseException(instring,len(instring),e.errmsg,self)

-                    maxExcLoc = len(instring)

-            else:

-                # save match among all matches, to retry longest to shortest

-                matches.append((loc2, e))

-

-        if matches:

-            matches.sort(key=lambda x: -x[0])

-            for _,e in matches:

-                try:

-                    return e._parse( instring, loc, doActions )

-                except ParseException as err:

-                    err.__traceback__ = None

-                    if err.loc > maxExcLoc:

-                        maxException = err

-                        maxExcLoc = err.loc

-

-        if maxException is not None:

-            maxException.msg = self.errmsg

-            raise maxException

-        else:

-            raise ParseException(instring, loc, "no defined alternatives to match", self)

-

-

-    def __ixor__(self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        return self.append( other ) #Or( [ self, other ] )

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-

-

-class MatchFirst(ParseExpression):

-    """

-    Requires that at least one C{ParseExpression} is found.

-    If two expressions match, the first one listed is the one that will match.

-    May be constructed using the C{'|'} operator.

-

-    Example::

-        # construct MatchFirst using '|' operator

-        

-        # watch the order of expressions to match

-        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))

-        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]

-

-        # put more selective expression first

-        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)

-        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]

-    """

-    def __init__( self, exprs, savelist = False ):

-        super(MatchFirst,self).__init__(exprs, savelist)

-        if self.exprs:

-            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)

-        else:

-            self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        maxExcLoc = -1

-        maxException = None

-        for e in self.exprs:

-            try:

-                ret = e._parse( instring, loc, doActions )

-                return ret

-            except ParseException as err:

-                if err.loc > maxExcLoc:

-                    maxException = err

-                    maxExcLoc = err.loc

-            except IndexError:

-                if len(instring) > maxExcLoc:

-                    maxException = ParseException(instring,len(instring),e.errmsg,self)

-                    maxExcLoc = len(instring)

-

-        # only got here if no expression matched, raise exception for match that made it the furthest

-        else:

-            if maxException is not None:

-                maxException.msg = self.errmsg

-                raise maxException

-            else:

-                raise ParseException(instring, loc, "no defined alternatives to match", self)

-

-    def __ior__(self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass( other )

-        return self.append( other ) #MatchFirst( [ self, other ] )

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-

-

-class Each(ParseExpression):

-    """

-    Requires all given C{ParseExpression}s to be found, but in any order.

-    Expressions may be separated by whitespace.

-    May be constructed using the C{'&'} operator.

-

-    Example::

-        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")

-        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")

-        integer = Word(nums)

-        shape_attr = "shape:" + shape_type("shape")

-        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")

-        color_attr = "color:" + color("color")

-        size_attr = "size:" + integer("size")

-

-        # use Each (using operator '&') to accept attributes in any order 

-        # (shape and posn are required, color and size are optional)

-        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)

-

-        shape_spec.runTests('''

-            shape: SQUARE color: BLACK posn: 100, 120

-            shape: CIRCLE size: 50 color: BLUE posn: 50,80

-            color:GREEN size:20 shape:TRIANGLE posn:20,40

-            '''

-            )

-    prints::

-        shape: SQUARE color: BLACK posn: 100, 120

-        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]

-        - color: BLACK

-        - posn: ['100', ',', '120']

-          - x: 100

-          - y: 120

-        - shape: SQUARE

-

-

-        shape: CIRCLE size: 50 color: BLUE posn: 50,80

-        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]

-        - color: BLUE

-        - posn: ['50', ',', '80']

-          - x: 50

-          - y: 80

-        - shape: CIRCLE

-        - size: 50

-

-

-        color: GREEN size: 20 shape: TRIANGLE posn: 20,40

-        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]

-        - color: GREEN

-        - posn: ['20', ',', '40']

-          - x: 20

-          - y: 40

-        - shape: TRIANGLE

-        - size: 20

-    """

-    def __init__( self, exprs, savelist = True ):

-        super(Each,self).__init__(exprs, savelist)

-        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)

-        self.skipWhitespace = True

-        self.initExprGroups = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.initExprGroups:

-            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))

-            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]

-            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]

-            self.optionals = opt1 + opt2

-            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]

-            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]

-            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]

-            self.required += self.multirequired

-            self.initExprGroups = False

-        tmpLoc = loc

-        tmpReqd = self.required[:]

-        tmpOpt  = self.optionals[:]

-        matchOrder = []

-

-        keepMatching = True

-        while keepMatching:

-            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired

-            failed = []

-            for e in tmpExprs:

-                try:

-                    tmpLoc = e.tryParse( instring, tmpLoc )

-                except ParseException:

-                    failed.append(e)

-                else:

-                    matchOrder.append(self.opt1map.get(id(e),e))

-                    if e in tmpReqd:

-                        tmpReqd.remove(e)

-                    elif e in tmpOpt:

-                        tmpOpt.remove(e)

-            if len(failed) == len(tmpExprs):

-                keepMatching = False

-

-        if tmpReqd:

-            missing = ", ".join(_ustr(e) for e in tmpReqd)

-            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )

-

-        # add any unmatched Optionals, in case they have default values defined

-        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]

-

-        resultlist = []

-        for e in matchOrder:

-            loc,results = e._parse(instring,loc,doActions)

-            resultlist.append(results)

-

-        finalResults = sum(resultlist, ParseResults([]))

-        return loc, finalResults

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"

-

-        return self.strRepr

-

-    def checkRecursion( self, parseElementList ):

-        subRecCheckList = parseElementList[:] + [ self ]

-        for e in self.exprs:

-            e.checkRecursion( subRecCheckList )

-

-

-class ParseElementEnhance(ParserElement):

-    """

-    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.

-    """

-    def __init__( self, expr, savelist=False ):

-        super(ParseElementEnhance,self).__init__(savelist)

-        if isinstance( expr, basestring ):

-            if issubclass(ParserElement._literalStringClass, Token):

-                expr = ParserElement._literalStringClass(expr)

-            else:

-                expr = ParserElement._literalStringClass(Literal(expr))

-        self.expr = expr

-        self.strRepr = None

-        if expr is not None:

-            self.mayIndexError = expr.mayIndexError

-            self.mayReturnEmpty = expr.mayReturnEmpty

-            self.setWhitespaceChars( expr.whiteChars )

-            self.skipWhitespace = expr.skipWhitespace

-            self.saveAsList = expr.saveAsList

-            self.callPreparse = expr.callPreparse

-            self.ignoreExprs.extend(expr.ignoreExprs)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.expr is not None:

-            return self.expr._parse( instring, loc, doActions, callPreParse=False )

-        else:

-            raise ParseException("",loc,self.errmsg,self)

-

-    def leaveWhitespace( self ):

-        self.skipWhitespace = False

-        self.expr = self.expr.copy()

-        if self.expr is not None:

-            self.expr.leaveWhitespace()

-        return self

-

-    def ignore( self, other ):

-        if isinstance( other, Suppress ):

-            if other not in self.ignoreExprs:

-                super( ParseElementEnhance, self).ignore( other )

-                if self.expr is not None:

-                    self.expr.ignore( self.ignoreExprs[-1] )

-        else:

-            super( ParseElementEnhance, self).ignore( other )

-            if self.expr is not None:

-                self.expr.ignore( self.ignoreExprs[-1] )

-        return self

-

-    def streamline( self ):

-        super(ParseElementEnhance,self).streamline()

-        if self.expr is not None:

-            self.expr.streamline()

-        return self

-

-    def checkRecursion( self, parseElementList ):

-        if self in parseElementList:

-            raise RecursiveGrammarException( parseElementList+[self] )

-        subRecCheckList = parseElementList[:] + [ self ]

-        if self.expr is not None:

-            self.expr.checkRecursion( subRecCheckList )

-

-    def validate( self, validateTrace=[] ):

-        tmp = validateTrace[:]+[self]

-        if self.expr is not None:

-            self.expr.validate(tmp)

-        self.checkRecursion( [] )

-

-    def __str__( self ):

-        try:

-            return super(ParseElementEnhance,self).__str__()

-        except Exception:

-            pass

-

-        if self.strRepr is None and self.expr is not None:

-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )

-        return self.strRepr

-

-

-class FollowedBy(ParseElementEnhance):

-    """

-    Lookahead matching of the given parse expression.  C{FollowedBy}

-    does I{not} advance the parsing position within the input string, it only

-    verifies that the specified parse expression matches at the current

-    position.  C{FollowedBy} always returns a null token list.

-

-    Example::

-        # use FollowedBy to match a label only if it is followed by a ':'

-        data_word = Word(alphas)

-        label = data_word + FollowedBy(':')

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        

-        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()

-    prints::

-        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]

-    """

-    def __init__( self, expr ):

-        super(FollowedBy,self).__init__(expr)

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        self.expr.tryParse( instring, loc )

-        return loc, []

-

-

-class NotAny(ParseElementEnhance):

-    """

-    Lookahead to disallow matching with the given parse expression.  C{NotAny}

-    does I{not} advance the parsing position within the input string, it only

-    verifies that the specified parse expression does I{not} match at the current

-    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}

-    always returns a null token list.  May be constructed using the '~' operator.

-

-    Example::

-        

-    """

-    def __init__( self, expr ):

-        super(NotAny,self).__init__(expr)

-        #~ self.leaveWhitespace()

-        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs

-        self.mayReturnEmpty = True

-        self.errmsg = "Found unwanted token, "+_ustr(self.expr)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        if self.expr.canParseNext(instring, loc):

-            raise ParseException(instring, loc, self.errmsg, self)

-        return loc, []

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "~{" + _ustr(self.expr) + "}"

-

-        return self.strRepr

-

-class _MultipleMatch(ParseElementEnhance):

-    def __init__( self, expr, stopOn=None):

-        super(_MultipleMatch, self).__init__(expr)

-        self.saveAsList = True

-        ender = stopOn

-        if isinstance(ender, basestring):

-            ender = ParserElement._literalStringClass(ender)

-        self.not_ender = ~ender if ender is not None else None

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        self_expr_parse = self.expr._parse

-        self_skip_ignorables = self._skipIgnorables

-        check_ender = self.not_ender is not None

-        if check_ender:

-            try_not_ender = self.not_ender.tryParse

-        

-        # must be at least one (but first see if we are the stopOn sentinel;

-        # if so, fail)

-        if check_ender:

-            try_not_ender(instring, loc)

-        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )

-        try:

-            hasIgnoreExprs = (not not self.ignoreExprs)

-            while 1:

-                if check_ender:

-                    try_not_ender(instring, loc)

-                if hasIgnoreExprs:

-                    preloc = self_skip_ignorables( instring, loc )

-                else:

-                    preloc = loc

-                loc, tmptokens = self_expr_parse( instring, preloc, doActions )

-                if tmptokens or tmptokens.haskeys():

-                    tokens += tmptokens

-        except (ParseException,IndexError):

-            pass

-

-        return loc, tokens

-        

-class OneOrMore(_MultipleMatch):

-    """

-    Repetition of one or more of the given expression.

-    

-    Parameters:

-     - expr - expression that must match one or more times

-     - stopOn - (default=C{None}) - expression for a terminating sentinel

-          (only required if the sentinel would ordinarily match the repetition 

-          expression)          

-

-    Example::

-        data_word = Word(alphas)

-        label = data_word + FollowedBy(':')

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

-

-        text = "shape: SQUARE posn: upper left color: BLACK"

-        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]

-

-        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]

-        

-        # could also be written as

-        (attr_expr * (1,)).parseString(text).pprint()

-    """

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "{" + _ustr(self.expr) + "}..."

-

-        return self.strRepr

-

-class ZeroOrMore(_MultipleMatch):

-    """

-    Optional repetition of zero or more of the given expression.

-    

-    Parameters:

-     - expr - expression that must match zero or more times

-     - stopOn - (default=C{None}) - expression for a terminating sentinel

-          (only required if the sentinel would ordinarily match the repetition 

-          expression)          

-

-    Example: similar to L{OneOrMore}

-    """

-    def __init__( self, expr, stopOn=None):

-        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)

-        self.mayReturnEmpty = True

-        

-    def parseImpl( self, instring, loc, doActions=True ):

-        try:

-            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)

-        except (ParseException,IndexError):

-            return loc, []

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "[" + _ustr(self.expr) + "]..."

-

-        return self.strRepr

-

-class _NullToken(object):

-    def __bool__(self):

-        return False

-    __nonzero__ = __bool__

-    def __str__(self):

-        return ""

-

-_optionalNotMatched = _NullToken()

-class Optional(ParseElementEnhance):

-    """

-    Optional matching of the given expression.

-

-    Parameters:

-     - expr - expression that must match zero or more times

-     - default (optional) - value to be returned if the optional expression is not found.

-

-    Example::

-        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier

-        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))

-        zip.runTests('''

-            # traditional ZIP code

-            12345

-            

-            # ZIP+4 form

-            12101-0001

-            

-            # invalid ZIP

-            98765-

-            ''')

-    prints::

-        # traditional ZIP code

-        12345

-        ['12345']

-

-        # ZIP+4 form

-        12101-0001

-        ['12101-0001']

-

-        # invalid ZIP

-        98765-

-             ^

-        FAIL: Expected end of text (at char 5), (line:1, col:6)

-    """

-    def __init__( self, expr, default=_optionalNotMatched ):

-        super(Optional,self).__init__( expr, savelist=False )

-        self.saveAsList = self.expr.saveAsList

-        self.defaultValue = default

-        self.mayReturnEmpty = True

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        try:

-            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )

-        except (ParseException,IndexError):

-            if self.defaultValue is not _optionalNotMatched:

-                if self.expr.resultsName:

-                    tokens = ParseResults([ self.defaultValue ])

-                    tokens[self.expr.resultsName] = self.defaultValue

-                else:

-                    tokens = [ self.defaultValue ]

-            else:

-                tokens = []

-        return loc, tokens

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-

-        if self.strRepr is None:

-            self.strRepr = "[" + _ustr(self.expr) + "]"

-

-        return self.strRepr

-

-class SkipTo(ParseElementEnhance):

-    """

-    Token for skipping over all undefined text until the matched expression is found.

-

-    Parameters:

-     - expr - target expression marking the end of the data to be skipped

-     - include - (default=C{False}) if True, the target expression is also parsed 

-          (the skipped text and target expression are returned as a 2-element list).

-     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 

-          comments) that might contain false matches to the target expression

-     - failOn - (default=C{None}) define expressions that are not allowed to be 

-          included in the skipped test; if found before the target expression is found, 

-          the SkipTo is not a match

-

-    Example::

-        report = '''

-            Outstanding Issues Report - 1 Jan 2000

-

-               # | Severity | Description                               |  Days Open

-            -----+----------+-------------------------------------------+-----------

-             101 | Critical | Intermittent system crash                 |          6

-              94 | Cosmetic | Spelling error on Login ('log|n')         |         14

-              79 | Minor    | System slow when running too many reports |         47

-            '''

-        integer = Word(nums)

-        SEP = Suppress('|')

-        # use SkipTo to simply match everything up until the next SEP

-        # - ignore quoted strings, so that a '|' character inside a quoted string does not match

-        # - parse action will call token.strip() for each matched token, i.e., the description body

-        string_data = SkipTo(SEP, ignore=quotedString)

-        string_data.setParseAction(tokenMap(str.strip))

-        ticket_expr = (integer("issue_num") + SEP 

-                      + string_data("sev") + SEP 

-                      + string_data("desc") + SEP 

-                      + integer("days_open"))

-        

-        for tkt in ticket_expr.searchString(report):

-            print tkt.dump()

-    prints::

-        ['101', 'Critical', 'Intermittent system crash', '6']

-        - days_open: 6

-        - desc: Intermittent system crash

-        - issue_num: 101

-        - sev: Critical

-        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']

-        - days_open: 14

-        - desc: Spelling error on Login ('log|n')

-        - issue_num: 94

-        - sev: Cosmetic

-        ['79', 'Minor', 'System slow when running too many reports', '47']

-        - days_open: 47

-        - desc: System slow when running too many reports

-        - issue_num: 79

-        - sev: Minor

-    """

-    def __init__( self, other, include=False, ignore=None, failOn=None ):

-        super( SkipTo, self ).__init__( other )

-        self.ignoreExpr = ignore

-        self.mayReturnEmpty = True

-        self.mayIndexError = False

-        self.includeMatch = include

-        self.asList = False

-        if isinstance(failOn, basestring):

-            self.failOn = ParserElement._literalStringClass(failOn)

-        else:

-            self.failOn = failOn

-        self.errmsg = "No match found for "+_ustr(self.expr)

-

-    def parseImpl( self, instring, loc, doActions=True ):

-        startloc = loc

-        instrlen = len(instring)

-        expr = self.expr

-        expr_parse = self.expr._parse

-        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None

-        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None

-        

-        tmploc = loc

-        while tmploc <= instrlen:

-            if self_failOn_canParseNext is not None:

-                # break if failOn expression matches

-                if self_failOn_canParseNext(instring, tmploc):

-                    break

-                    

-            if self_ignoreExpr_tryParse is not None:

-                # advance past ignore expressions

-                while 1:

-                    try:

-                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)

-                    except ParseBaseException:

-                        break

-            

-            try:

-                expr_parse(instring, tmploc, doActions=False, callPreParse=False)

-            except (ParseException, IndexError):

-                # no match, advance loc in string

-                tmploc += 1

-            else:

-                # matched skipto expr, done

-                break

-

-        else:

-            # ran off the end of the input string without matching skipto expr, fail

-            raise ParseException(instring, loc, self.errmsg, self)

-

-        # build up return values

-        loc = tmploc

-        skiptext = instring[startloc:loc]

-        skipresult = ParseResults(skiptext)

-        

-        if self.includeMatch:

-            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)

-            skipresult += mat

-

-        return loc, skipresult

-

-class Forward(ParseElementEnhance):

-    """

-    Forward declaration of an expression to be defined later -

-    used for recursive grammars, such as algebraic infix notation.

-    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.

-

-    Note: take care when assigning to C{Forward} not to overlook precedence of operators.

-    Specifically, '|' has a lower precedence than '<<', so that::

-        fwdExpr << a | b | c

-    will actually be evaluated as::

-        (fwdExpr << a) | b | c

-    thereby leaving b and c out as parseable alternatives.  It is recommended that you

-    explicitly group the values inserted into the C{Forward}::

-        fwdExpr << (a | b | c)

-    Converting to use the '<<=' operator instead will avoid this problem.

-

-    See L{ParseResults.pprint} for an example of a recursive parser created using

-    C{Forward}.

-    """

-    def __init__( self, other=None ):

-        super(Forward,self).__init__( other, savelist=False )

-

-    def __lshift__( self, other ):

-        if isinstance( other, basestring ):

-            other = ParserElement._literalStringClass(other)

-        self.expr = other

-        self.strRepr = None

-        self.mayIndexError = self.expr.mayIndexError

-        self.mayReturnEmpty = self.expr.mayReturnEmpty

-        self.setWhitespaceChars( self.expr.whiteChars )

-        self.skipWhitespace = self.expr.skipWhitespace

-        self.saveAsList = self.expr.saveAsList

-        self.ignoreExprs.extend(self.expr.ignoreExprs)

-        return self

-        

-    def __ilshift__(self, other):

-        return self << other

-    

-    def leaveWhitespace( self ):

-        self.skipWhitespace = False

-        return self

-

-    def streamline( self ):

-        if not self.streamlined:

-            self.streamlined = True

-            if self.expr is not None:

-                self.expr.streamline()

-        return self

-

-    def validate( self, validateTrace=[] ):

-        if self not in validateTrace:

-            tmp = validateTrace[:]+[self]

-            if self.expr is not None:

-                self.expr.validate(tmp)

-        self.checkRecursion([])

-

-    def __str__( self ):

-        if hasattr(self,"name"):

-            return self.name

-        return self.__class__.__name__ + ": ..."

-

-        # stubbed out for now - creates awful memory and perf issues

-        self._revertClass = self.__class__

-        self.__class__ = _ForwardNoRecurse

-        try:

-            if self.expr is not None:

-                retString = _ustr(self.expr)

-            else:

-                retString = "None"

-        finally:

-            self.__class__ = self._revertClass

-        return self.__class__.__name__ + ": " + retString

-

-    def copy(self):

-        if self.expr is not None:

-            return super(Forward,self).copy()

-        else:

-            ret = Forward()

-            ret <<= self

-            return ret

-

-class _ForwardNoRecurse(Forward):

-    def __str__( self ):

-        return "..."

-

-class TokenConverter(ParseElementEnhance):

-    """

-    Abstract subclass of C{ParseExpression}, for converting parsed results.

-    """

-    def __init__( self, expr, savelist=False ):

-        super(TokenConverter,self).__init__( expr )#, savelist )

-        self.saveAsList = False

-

-class Combine(TokenConverter):

-    """

-    Converter to concatenate all matching tokens to a single string.

-    By default, the matching patterns must also be contiguous in the input string;

-    this can be disabled by specifying C{'adjacent=False'} in the constructor.

-

-    Example::

-        real = Word(nums) + '.' + Word(nums)

-        print(real.parseString('3.1416')) # -> ['3', '.', '1416']

-        # will also erroneously match the following

-        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']

-

-        real = Combine(Word(nums) + '.' + Word(nums))

-        print(real.parseString('3.1416')) # -> ['3.1416']

-        # no match when there are internal spaces

-        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)

-    """

-    def __init__( self, expr, joinString="", adjacent=True ):

-        super(Combine,self).__init__( expr )

-        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself

-        if adjacent:

-            self.leaveWhitespace()

-        self.adjacent = adjacent

-        self.skipWhitespace = True

-        self.joinString = joinString

-        self.callPreparse = True

-

-    def ignore( self, other ):

-        if self.adjacent:

-            ParserElement.ignore(self, other)

-        else:

-            super( Combine, self).ignore( other )

-        return self

-

-    def postParse( self, instring, loc, tokenlist ):

-        retToks = tokenlist.copy()

-        del retToks[:]

-        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)

-

-        if self.resultsName and retToks.haskeys():

-            return [ retToks ]

-        else:

-            return retToks

-

-class Group(TokenConverter):

-    """

-    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.

-

-    Example::

-        ident = Word(alphas)

-        num = Word(nums)

-        term = ident | num

-        func = ident + Optional(delimitedList(term))

-        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']

-

-        func = ident + Group(Optional(delimitedList(term)))

-        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]

-    """

-    def __init__( self, expr ):

-        super(Group,self).__init__( expr )

-        self.saveAsList = True

-

-    def postParse( self, instring, loc, tokenlist ):

-        return [ tokenlist ]

-

-class Dict(TokenConverter):

-    """

-    Converter to return a repetitive expression as a list, but also as a dictionary.

-    Each element can also be referenced using the first token in the expression as its key.

-    Useful for tabular report scraping when the first column can be used as a item key.

-

-    Example::

-        data_word = Word(alphas)

-        label = data_word + FollowedBy(':')

-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))

-

-        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"

-        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        

-        # print attributes as plain groups

-        print(OneOrMore(attr_expr).parseString(text).dump())

-        

-        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names

-        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)

-        print(result.dump())

-        

-        # access named fields as dict entries, or output as dict

-        print(result['shape'])        

-        print(result.asDict())

-    prints::

-        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']

-

-        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]

-        - color: light blue

-        - posn: upper left

-        - shape: SQUARE

-        - texture: burlap

-        SQUARE

-        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}

-    See more examples at L{ParseResults} of accessing fields by results name.

-    """

-    def __init__( self, expr ):

-        super(Dict,self).__init__( expr )

-        self.saveAsList = True

-

-    def postParse( self, instring, loc, tokenlist ):

-        for i,tok in enumerate(tokenlist):

-            if len(tok) == 0:

-                continue

-            ikey = tok[0]

-            if isinstance(ikey,int):

-                ikey = _ustr(tok[0]).strip()

-            if len(tok)==1:

-                tokenlist[ikey] = _ParseResultsWithOffset("",i)

-            elif len(tok)==2 and not isinstance(tok[1],ParseResults):

-                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)

-            else:

-                dictvalue = tok.copy() #ParseResults(i)

-                del dictvalue[0]

-                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):

-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)

-                else:

-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)

-

-        if self.resultsName:

-            return [ tokenlist ]

-        else:

-            return tokenlist

-

-

-class Suppress(TokenConverter):

-    """

-    Converter for ignoring the results of a parsed expression.

-

-    Example::

-        source = "a, b, c,d"

-        wd = Word(alphas)

-        wd_list1 = wd + ZeroOrMore(',' + wd)

-        print(wd_list1.parseString(source))

-

-        # often, delimiters that are useful during parsing are just in the

-        # way afterward - use Suppress to keep them out of the parsed output

-        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)

-        print(wd_list2.parseString(source))

-    prints::

-        ['a', ',', 'b', ',', 'c', ',', 'd']

-        ['a', 'b', 'c', 'd']

-    (See also L{delimitedList}.)

-    """

-    def postParse( self, instring, loc, tokenlist ):

-        return []

-

-    def suppress( self ):

-        return self

-

-

-class OnlyOnce(object):

-    """

-    Wrapper for parse actions, to ensure they are only called once.

-    """

-    def __init__(self, methodCall):

-        self.callable = _trim_arity(methodCall)

-        self.called = False

-    def __call__(self,s,l,t):

-        if not self.called:

-            results = self.callable(s,l,t)

-            self.called = True

-            return results

-        raise ParseException(s,l,"")

-    def reset(self):

-        self.called = False

-

-def traceParseAction(f):

-    """

-    Decorator for debugging parse actions. 

-    

-    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}

-    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.

-

-    Example::

-        wd = Word(alphas)

-

-        @traceParseAction

-        def remove_duplicate_chars(tokens):

-            return ''.join(sorted(set(''.join(tokens))))

-

-        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)

-        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))

-    prints::

-        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))

-        <<leaving remove_duplicate_chars (ret: 'dfjkls')

-        ['dfjkls']

-    """

-    f = _trim_arity(f)

-    def z(*paArgs):

-        thisFunc = f.__name__

-        s,l,t = paArgs[-3:]

-        if len(paArgs)>3:

-            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc

-        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )

-        try:

-            ret = f(*paArgs)

-        except Exception as exc:

-            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )

-            raise

-        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) )

-        return ret

-    try:

-        z.__name__ = f.__name__

-    except AttributeError:

-        pass

-    return z

-

-#

-# global helpers

-#

-def delimitedList( expr, delim=",", combine=False ):

-    """

-    Helper to define a delimited list of expressions - the delimiter defaults to ','.

-    By default, the list elements and delimiters can have intervening whitespace, and

-    comments, but this can be overridden by passing C{combine=True} in the constructor.

-    If C{combine} is set to C{True}, the matching tokens are returned as a single token

-    string, with the delimiters included; otherwise, the matching tokens are returned

-    as a list of tokens, with the delimiters suppressed.

-

-    Example::

-        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']

-        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']

-    """

-    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."

-    if combine:

-        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)

-    else:

-        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)

-

-def countedArray( expr, intExpr=None ):

-    """

-    Helper to define a counted list of expressions.

-    This helper defines a pattern of the form::

-        integer expr expr expr...

-    where the leading integer tells how many expr expressions follow.

-    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.

-    

-    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.

-

-    Example::

-        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']

-

-        # in this parser, the leading integer value is given in binary,

-        # '10' indicating that 2 values are in the array

-        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))

-        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']

-    """

-    arrayExpr = Forward()

-    def countFieldParseAction(s,l,t):

-        n = t[0]

-        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))

-        return []

-    if intExpr is None:

-        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))

-    else:

-        intExpr = intExpr.copy()

-    intExpr.setName("arrayLen")

-    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)

-    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')

-

-def _flatten(L):

-    ret = []

-    for i in L:

-        if isinstance(i,list):

-            ret.extend(_flatten(i))

-        else:

-            ret.append(i)

-    return ret

-

-def matchPreviousLiteral(expr):

-    """

-    Helper to define an expression that is indirectly defined from

-    the tokens matched in a previous expression, that is, it looks

-    for a 'repeat' of a previous expression.  For example::

-        first = Word(nums)

-        second = matchPreviousLiteral(first)

-        matchExpr = first + ":" + second

-    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a

-    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.

-    If this is not desired, use C{matchPreviousExpr}.

-    Do I{not} use with packrat parsing enabled.

-    """

-    rep = Forward()

-    def copyTokenToRepeater(s,l,t):

-        if t:

-            if len(t) == 1:

-                rep << t[0]

-            else:

-                # flatten t tokens

-                tflat = _flatten(t.asList())

-                rep << And(Literal(tt) for tt in tflat)

-        else:

-            rep << Empty()

-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)

-    rep.setName('(prev) ' + _ustr(expr))

-    return rep

-

-def matchPreviousExpr(expr):

-    """

-    Helper to define an expression that is indirectly defined from

-    the tokens matched in a previous expression, that is, it looks

-    for a 'repeat' of a previous expression.  For example::

-        first = Word(nums)

-        second = matchPreviousExpr(first)

-        matchExpr = first + ":" + second

-    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by

-    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};

-    the expressions are evaluated first, and then compared, so

-    C{"1"} is compared with C{"10"}.

-    Do I{not} use with packrat parsing enabled.

-    """

-    rep = Forward()

-    e2 = expr.copy()

-    rep <<= e2

-    def copyTokenToRepeater(s,l,t):

-        matchTokens = _flatten(t.asList())

-        def mustMatchTheseTokens(s,l,t):

-            theseTokens = _flatten(t.asList())

-            if  theseTokens != matchTokens:

-                raise ParseException("",0,"")

-        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )

-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)

-    rep.setName('(prev) ' + _ustr(expr))

-    return rep

-

-def _escapeRegexRangeChars(s):

-    #~  escape these chars: ^-]

-    for c in r"\^-]":

-        s = s.replace(c,_bslash+c)

-    s = s.replace("\n",r"\n")

-    s = s.replace("\t",r"\t")

-    return _ustr(s)

-

-def oneOf( strs, caseless=False, useRegex=True ):

-    """

-    Helper to quickly define a set of alternative Literals, and makes sure to do

-    longest-first testing when there is a conflict, regardless of the input order,

-    but returns a C{L{MatchFirst}} for best performance.

-

-    Parameters:

-     - strs - a string of space-delimited literals, or a collection of string literals

-     - caseless - (default=C{False}) - treat all literals as caseless

-     - useRegex - (default=C{True}) - as an optimization, will generate a Regex

-          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or

-          if creating a C{Regex} raises an exception)

-

-    Example::

-        comp_oper = oneOf("< = > <= >= !=")

-        var = Word(alphas)

-        number = Word(nums)

-        term = var | number

-        comparison_expr = term + comp_oper + term

-        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))

-    prints::

-        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]

-    """

-    if caseless:

-        isequal = ( lambda a,b: a.upper() == b.upper() )

-        masks = ( lambda a,b: b.upper().startswith(a.upper()) )

-        parseElementClass = CaselessLiteral

-    else:

-        isequal = ( lambda a,b: a == b )

-        masks = ( lambda a,b: b.startswith(a) )

-        parseElementClass = Literal

-

-    symbols = []

-    if isinstance(strs,basestring):

-        symbols = strs.split()

-    elif isinstance(strs, Iterable):

-        symbols = list(strs)

-    else:

-        warnings.warn("Invalid argument to oneOf, expected string or iterable",

-                SyntaxWarning, stacklevel=2)

-    if not symbols:

-        return NoMatch()

-

-    i = 0

-    while i < len(symbols)-1:

-        cur = symbols[i]

-        for j,other in enumerate(symbols[i+1:]):

-            if ( isequal(other, cur) ):

-                del symbols[i+j+1]

-                break

-            elif ( masks(cur, other) ):

-                del symbols[i+j+1]

-                symbols.insert(i,other)

-                cur = other

-                break

-        else:

-            i += 1

-

-    if not caseless and useRegex:

-        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))

-        try:

-            if len(symbols)==len("".join(symbols)):

-                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))

-            else:

-                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))

-        except Exception:

-            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",

-                    SyntaxWarning, stacklevel=2)

-

-

-    # last resort, just use MatchFirst

-    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))

-

-def dictOf( key, value ):

-    """

-    Helper to easily and clearly define a dictionary by specifying the respective patterns

-    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens

-    in the proper order.  The key pattern can include delimiting markers or punctuation,

-    as long as they are suppressed, thereby leaving the significant key text.  The value

-    pattern can include named results, so that the C{Dict} results can include named token

-    fields.

-

-    Example::

-        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"

-        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))

-        print(OneOrMore(attr_expr).parseString(text).dump())

-        

-        attr_label = label

-        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)

-

-        # similar to Dict, but simpler call format

-        result = dictOf(attr_label, attr_value).parseString(text)

-        print(result.dump())

-        print(result['shape'])

-        print(result.shape)  # object attribute access works too

-        print(result.asDict())

-    prints::

-        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]

-        - color: light blue

-        - posn: upper left

-        - shape: SQUARE

-        - texture: burlap

-        SQUARE

-        SQUARE

-        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}

-    """

-    return Dict( ZeroOrMore( Group ( key + value ) ) )

-

-def originalTextFor(expr, asString=True):

-    """

-    Helper to return the original, untokenized text for a given expression.  Useful to

-    restore the parsed fields of an HTML start tag into the raw tag text itself, or to

-    revert separate tokens with intervening whitespace back to the original matching

-    input text. By default, returns astring containing the original parsed text.  

-       

-    If the optional C{asString} argument is passed as C{False}, then the return value is a 

-    C{L{ParseResults}} containing any results names that were originally matched, and a 

-    single token containing the original matched text from the input string.  So if 

-    the expression passed to C{L{originalTextFor}} contains expressions with defined

-    results names, you must set C{asString} to C{False} if you want to preserve those

-    results name values.

-

-    Example::

-        src = "this is test <b> bold <i>text</i> </b> normal text "

-        for tag in ("b","i"):

-            opener,closer = makeHTMLTags(tag)

-            patt = originalTextFor(opener + SkipTo(closer) + closer)

-            print(patt.searchString(src)[0])

-    prints::

-        ['<b> bold <i>text</i> </b>']

-        ['<i>text</i>']

-    """

-    locMarker = Empty().setParseAction(lambda s,loc,t: loc)

-    endlocMarker = locMarker.copy()

-    endlocMarker.callPreparse = False

-    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")

-    if asString:

-        extractText = lambda s,l,t: s[t._original_start:t._original_end]

-    else:

-        def extractText(s,l,t):

-            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]

-    matchExpr.setParseAction(extractText)

-    matchExpr.ignoreExprs = expr.ignoreExprs

-    return matchExpr

-

-def ungroup(expr): 

-    """

-    Helper to undo pyparsing's default grouping of And expressions, even

-    if all but one are non-empty.

-    """

-    return TokenConverter(expr).setParseAction(lambda t:t[0])

-

-def locatedExpr(expr):

-    """

-    Helper to decorate a returned token with its starting and ending locations in the input string.

-    This helper adds the following results names:

-     - locn_start = location where matched expression begins

-     - locn_end = location where matched expression ends

-     - value = the actual parsed results

-

-    Be careful if the input text contains C{<TAB>} characters, you may want to call

-    C{L{ParserElement.parseWithTabs}}

-

-    Example::

-        wd = Word(alphas)

-        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):

-            print(match)

-    prints::

-        [[0, 'ljsdf', 5]]

-        [[8, 'lksdjjf', 15]]

-        [[18, 'lkkjj', 23]]

-    """

-    locator = Empty().setParseAction(lambda s,l,t: l)

-    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))

-

-

-# convenience constants for positional expressions

-empty       = Empty().setName("empty")

-lineStart   = LineStart().setName("lineStart")

-lineEnd     = LineEnd().setName("lineEnd")

-stringStart = StringStart().setName("stringStart")

-stringEnd   = StringEnd().setName("stringEnd")

-

-_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])

-_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))

-_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))

-_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)

-_charRange = Group(_singleChar + Suppress("-") + _singleChar)

-_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"

-

-def srange(s):

-    r"""

-    Helper to easily define string ranges for use in Word construction.  Borrows

-    syntax from regexp '[]' string range definitions::

-        srange("[0-9]")   -> "0123456789"

-        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"

-        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"

-    The input string must be enclosed in []'s, and the returned string is the expanded

-    character set joined into a single string.

-    The values enclosed in the []'s may be:

-     - a single character

-     - an escaped character with a leading backslash (such as C{\-} or C{\]})

-     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 

-         (C{\0x##} is also supported for backwards compatibility) 

-     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)

-     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)

-     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)

-    """

-    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))

-    try:

-        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)

-    except Exception:

-        return ""

-

-def matchOnlyAtCol(n):

-    """

-    Helper method for defining parse actions that require matching at a specific

-    column in the input text.

-    """

-    def verifyCol(strg,locn,toks):

-        if col(locn,strg) != n:

-            raise ParseException(strg,locn,"matched token not at column %d" % n)

-    return verifyCol

-

-def replaceWith(replStr):

-    """

-    Helper method for common parse actions that simply return a literal value.  Especially

-    useful when used with C{L{transformString<ParserElement.transformString>}()}.

-

-    Example::

-        num = Word(nums).setParseAction(lambda toks: int(toks[0]))

-        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))

-        term = na | num

-        

-        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]

-    """

-    return lambda s,l,t: [replStr]

-

-def removeQuotes(s,l,t):

-    """

-    Helper parse action for removing quotation marks from parsed quoted strings.

-

-    Example::

-        # by default, quotation marks are included in parsed results

-        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]

-

-        # use removeQuotes to strip quotation marks from parsed results

-        quotedString.setParseAction(removeQuotes)

-        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]

-    """

-    return t[0][1:-1]

-

-def tokenMap(func, *args):

-    """

-    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 

-    args are passed, they are forwarded to the given function as additional arguments after

-    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the

-    parsed data to an integer using base 16.

-

-    Example (compare the last to example in L{ParserElement.transformString}::

-        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))

-        hex_ints.runTests('''

-            00 11 22 aa FF 0a 0d 1a

-            ''')

-        

-        upperword = Word(alphas).setParseAction(tokenMap(str.upper))

-        OneOrMore(upperword).runTests('''

-            my kingdom for a horse

-            ''')

-

-        wd = Word(alphas).setParseAction(tokenMap(str.title))

-        OneOrMore(wd).setParseAction(' '.join).runTests('''

-            now is the winter of our discontent made glorious summer by this sun of york

-            ''')

-    prints::

-        00 11 22 aa FF 0a 0d 1a

-        [0, 17, 34, 170, 255, 10, 13, 26]

-

-        my kingdom for a horse

-        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']

-

-        now is the winter of our discontent made glorious summer by this sun of york

-        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']

-    """

-    def pa(s,l,t):

-        return [func(tokn, *args) for tokn in t]

-

-    try:

-        func_name = getattr(func, '__name__', 

-                            getattr(func, '__class__').__name__)

-    except Exception:

-        func_name = str(func)

-    pa.__name__ = func_name

-

-    return pa

-

-upcaseTokens = tokenMap(lambda t: _ustr(t).upper())

-"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""

-

-downcaseTokens = tokenMap(lambda t: _ustr(t).lower())

-"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""

-    

-def _makeTags(tagStr, xml):

-    """Internal helper to construct opening and closing tag expressions, given a tag name"""

-    if isinstance(tagStr,basestring):

-        resname = tagStr

-        tagStr = Keyword(tagStr, caseless=not xml)

-    else:

-        resname = tagStr.name

-

-    tagAttrName = Word(alphas,alphanums+"_-:")

-    if (xml):

-        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )

-        openTag = Suppress("<") + tagStr("tag") + \

-                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \

-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")

-    else:

-        printablesLessRAbrack = "".join(c for c in printables if c not in ">")

-        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)

-        openTag = Suppress("<") + tagStr("tag") + \

-                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \

-                Optional( Suppress("=") + tagAttrValue ) ))) + \

-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")

-    closeTag = Combine(_L("</") + tagStr + ">")

-

-    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)

-    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname)

-    openTag.tag = resname

-    closeTag.tag = resname

-    return openTag, closeTag

-

-def makeHTMLTags(tagStr):

-    """

-    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches

-    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.

-

-    Example::

-        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'

-        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple

-        a,a_end = makeHTMLTags("A")

-        link_expr = a + SkipTo(a_end)("link_text") + a_end

-        

-        for link in link_expr.searchString(text):

-            # attributes in the <A> tag (like "href" shown here) are also accessible as named results

-            print(link.link_text, '->', link.href)

-    prints::

-        pyparsing -> http://pyparsing.wikispaces.com

-    """

-    return _makeTags( tagStr, False )

-

-def makeXMLTags(tagStr):

-    """

-    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches

-    tags only in the given upper/lower case.

-

-    Example: similar to L{makeHTMLTags}

-    """

-    return _makeTags( tagStr, True )

-

-def withAttribute(*args,**attrDict):

-    """

-    Helper to create a validating parse action to be used with start tags created

-    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag

-    with a required attribute value, to avoid false matches on common tags such as

-    C{<TD>} or C{<DIV>}.

-

-    Call C{withAttribute} with a series of attribute names and values. Specify the list

-    of filter attributes names and values as:

-     - keyword arguments, as in C{(align="right")}, or

-     - as an explicit dict with C{**} operator, when an attribute name is also a Python

-          reserved word, as in C{**{"class":"Customer", "align":"right"}}

-     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )

-    For attribute names with a namespace prefix, you must use the second form.  Attribute

-    names are matched insensitive to upper/lower case.

-       

-    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.

-

-    To verify that the attribute exists, but without specifying a value, pass

-    C{withAttribute.ANY_VALUE} as the value.

-

-    Example::

-        html = '''

-            <div>

-            Some text

-            <div type="grid">1 4 0 1 0</div>

-            <div type="graph">1,3 2,3 1,1</div>

-            <div>this has no type</div>

-            </div>

-                

-        '''

-        div,div_end = makeHTMLTags("div")

-

-        # only match div tag having a type attribute with value "grid"

-        div_grid = div().setParseAction(withAttribute(type="grid"))

-        grid_expr = div_grid + SkipTo(div | div_end)("body")

-        for grid_header in grid_expr.searchString(html):

-            print(grid_header.body)

-        

-        # construct a match with any div tag having a type attribute, regardless of the value

-        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))

-        div_expr = div_any_type + SkipTo(div | div_end)("body")

-        for div_header in div_expr.searchString(html):

-            print(div_header.body)

-    prints::

-        1 4 0 1 0

-

-        1 4 0 1 0

-        1,3 2,3 1,1

-    """

-    if args:

-        attrs = args[:]

-    else:

-        attrs = attrDict.items()

-    attrs = [(k,v) for k,v in attrs]

-    def pa(s,l,tokens):

-        for attrName,attrValue in attrs:

-            if attrName not in tokens:

-                raise ParseException(s,l,"no matching attribute " + attrName)

-            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:

-                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %

-                                            (attrName, tokens[attrName], attrValue))

-    return pa

-withAttribute.ANY_VALUE = object()

-

-def withClass(classname, namespace=''):

-    """

-    Simplified version of C{L{withAttribute}} when matching on a div class - made

-    difficult because C{class} is a reserved word in Python.

-

-    Example::

-        html = '''

-            <div>

-            Some text

-            <div class="grid">1 4 0 1 0</div>

-            <div class="graph">1,3 2,3 1,1</div>

-            <div>this &lt;div&gt; has no class</div>

-            </div>

-                

-        '''

-        div,div_end = makeHTMLTags("div")

-        div_grid = div().setParseAction(withClass("grid"))

-        

-        grid_expr = div_grid + SkipTo(div | div_end)("body")

-        for grid_header in grid_expr.searchString(html):

-            print(grid_header.body)

-        

-        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))

-        div_expr = div_any_type + SkipTo(div | div_end)("body")

-        for div_header in div_expr.searchString(html):

-            print(div_header.body)

-    prints::

-        1 4 0 1 0

-

-        1 4 0 1 0

-        1,3 2,3 1,1

-    """

-    classattr = "%s:class" % namespace if namespace else "class"

-    return withAttribute(**{classattr : classname})        

-

-opAssoc = _Constants()

-opAssoc.LEFT = object()

-opAssoc.RIGHT = object()

-

-def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):

-    """

-    Helper method for constructing grammars of expressions made up of

-    operators working in a precedence hierarchy.  Operators may be unary or

-    binary, left- or right-associative.  Parse actions can also be attached

-    to operator expressions. The generated parser will also recognize the use 

-    of parentheses to override operator precedences (see example below).

-    

-    Note: if you define a deep operator list, you may see performance issues

-    when using infixNotation. See L{ParserElement.enablePackrat} for a

-    mechanism to potentially improve your parser performance.

-

-    Parameters:

-     - baseExpr - expression representing the most basic element for the nested

-     - opList - list of tuples, one for each operator precedence level in the

-      expression grammar; each tuple is of the form

-      (opExpr, numTerms, rightLeftAssoc, parseAction), where:

-       - opExpr is the pyparsing expression for the operator;

-          may also be a string, which will be converted to a Literal;

-          if numTerms is 3, opExpr is a tuple of two expressions, for the

-          two operators separating the 3 terms

-       - numTerms is the number of terms for this operator (must

-          be 1, 2, or 3)

-       - rightLeftAssoc is the indicator whether the operator is

-          right or left associative, using the pyparsing-defined

-          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.

-       - parseAction is the parse action to be associated with

-          expressions matching this operator expression (the

-          parse action tuple member may be omitted); if the parse action

-          is passed a tuple or list of functions, this is equivalent to

-          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})

-     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})

-     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})

-

-    Example::

-        # simple example of four-function arithmetic with ints and variable names

-        integer = pyparsing_common.signed_integer

-        varname = pyparsing_common.identifier 

-        

-        arith_expr = infixNotation(integer | varname,

-            [

-            ('-', 1, opAssoc.RIGHT),

-            (oneOf('* /'), 2, opAssoc.LEFT),

-            (oneOf('+ -'), 2, opAssoc.LEFT),

-            ])

-        

-        arith_expr.runTests('''

-            5+3*6

-            (5+3)*6

-            -2--11

-            ''', fullDump=False)

-    prints::

-        5+3*6

-        [[5, '+', [3, '*', 6]]]

-

-        (5+3)*6

-        [[[5, '+', 3], '*', 6]]

-

-        -2--11

-        [[['-', 2], '-', ['-', 11]]]

-    """

-    ret = Forward()

-    lastExpr = baseExpr | ( lpar + ret + rpar )

-    for i,operDef in enumerate(opList):

-        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]

-        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr

-        if arity == 3:

-            if opExpr is None or len(opExpr) != 2:

-                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")

-            opExpr1, opExpr2 = opExpr

-        thisExpr = Forward().setName(termName)

-        if rightLeftAssoc == opAssoc.LEFT:

-            if arity == 1:

-                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )

-            elif arity == 2:

-                if opExpr is not None:

-                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )

-                else:

-                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )

-            elif arity == 3:

-                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \

-                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )

-            else:

-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")

-        elif rightLeftAssoc == opAssoc.RIGHT:

-            if arity == 1:

-                # try to avoid LR with this extra test

-                if not isinstance(opExpr, Optional):

-                    opExpr = Optional(opExpr)

-                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )

-            elif arity == 2:

-                if opExpr is not None:

-                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )

-                else:

-                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )

-            elif arity == 3:

-                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \

-                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )

-            else:

-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")

-        else:

-            raise ValueError("operator must indicate right or left associativity")

-        if pa:

-            if isinstance(pa, (tuple, list)):

-                matchExpr.setParseAction(*pa)

-            else:

-                matchExpr.setParseAction(pa)

-        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )

-        lastExpr = thisExpr

-    ret <<= lastExpr

-    return ret

-

-operatorPrecedence = infixNotation

-"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""

-

-dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")

-sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")

-quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|

-                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")

-unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")

-

-def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):

-    """

-    Helper method for defining nested lists enclosed in opening and closing

-    delimiters ("(" and ")" are the default).

-

-    Parameters:

-     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression

-     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression

-     - content - expression for items within the nested lists (default=C{None})

-     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})

-

-    If an expression is not provided for the content argument, the nested

-    expression will capture all whitespace-delimited content between delimiters

-    as a list of separate values.

-

-    Use the C{ignoreExpr} argument to define expressions that may contain

-    opening or closing characters that should not be treated as opening

-    or closing characters for nesting, such as quotedString or a comment

-    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.

-    The default is L{quotedString}, but if no expressions are to be ignored,

-    then pass C{None} for this argument.

-

-    Example::

-        data_type = oneOf("void int short long char float double")

-        decl_data_type = Combine(data_type + Optional(Word('*')))

-        ident = Word(alphas+'_', alphanums+'_')

-        number = pyparsing_common.number

-        arg = Group(decl_data_type + ident)

-        LPAR,RPAR = map(Suppress, "()")

-

-        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))

-

-        c_function = (decl_data_type("type") 

-                      + ident("name")

-                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 

-                      + code_body("body"))

-        c_function.ignore(cStyleComment)

-        

-        source_code = '''

-            int is_odd(int x) { 

-                return (x%2); 

-            }

-                

-            int dec_to_hex(char hchar) { 

-                if (hchar >= '0' && hchar <= '9') { 

-                    return (ord(hchar)-ord('0')); 

-                } else { 

-                    return (10+ord(hchar)-ord('A'));

-                } 

-            }

-        '''

-        for func in c_function.searchString(source_code):

-            print("%(name)s (%(type)s) args: %(args)s" % func)

-

-    prints::

-        is_odd (int) args: [['int', 'x']]

-        dec_to_hex (int) args: [['char', 'hchar']]

-    """

-    if opener == closer:

-        raise ValueError("opening and closing strings cannot be the same")

-    if content is None:

-        if isinstance(opener,basestring) and isinstance(closer,basestring):

-            if len(opener) == 1 and len(closer)==1:

-                if ignoreExpr is not None:

-                    content = (Combine(OneOrMore(~ignoreExpr +

-                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))

-                                ).setParseAction(lambda t:t[0].strip()))

-                else:

-                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS

-                                ).setParseAction(lambda t:t[0].strip()))

-            else:

-                if ignoreExpr is not None:

-                    content = (Combine(OneOrMore(~ignoreExpr + 

-                                    ~Literal(opener) + ~Literal(closer) +

-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))

-                                ).setParseAction(lambda t:t[0].strip()))

-                else:

-                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +

-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))

-                                ).setParseAction(lambda t:t[0].strip()))

-        else:

-            raise ValueError("opening and closing arguments must be strings if no content expression is given")

-    ret = Forward()

-    if ignoreExpr is not None:

-        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )

-    else:

-        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )

-    ret.setName('nested %s%s expression' % (opener,closer))

-    return ret

-

-def indentedBlock(blockStatementExpr, indentStack, indent=True):

-    """

-    Helper method for defining space-delimited indentation blocks, such as

-    those used to define block statements in Python source code.

-

-    Parameters:

-     - blockStatementExpr - expression defining syntax of statement that

-            is repeated within the indented block

-     - indentStack - list created by caller to manage indentation stack

-            (multiple statementWithIndentedBlock expressions within a single grammar

-            should share a common indentStack)

-     - indent - boolean indicating whether block must be indented beyond the

-            the current level; set to False for block of left-most statements

-            (default=C{True})

-

-    A valid block must contain at least one C{blockStatement}.

-

-    Example::

-        data = '''

-        def A(z):

-          A1

-          B = 100

-          G = A2

-          A2

-          A3

-        B

-        def BB(a,b,c):

-          BB1

-          def BBA():

-            bba1

-            bba2

-            bba3

-        C

-        D

-        def spam(x,y):

-             def eggs(z):

-                 pass

-        '''

-

-

-        indentStack = [1]

-        stmt = Forward()

-

-        identifier = Word(alphas, alphanums)

-        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")

-        func_body = indentedBlock(stmt, indentStack)

-        funcDef = Group( funcDecl + func_body )

-

-        rvalue = Forward()

-        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")

-        rvalue << (funcCall | identifier | Word(nums))

-        assignment = Group(identifier + "=" + rvalue)

-        stmt << ( funcDef | assignment | identifier )

-

-        module_body = OneOrMore(stmt)

-

-        parseTree = module_body.parseString(data)

-        parseTree.pprint()

-    prints::

-        [['def',

-          'A',

-          ['(', 'z', ')'],

-          ':',

-          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],

-         'B',

-         ['def',

-          'BB',

-          ['(', 'a', 'b', 'c', ')'],

-          ':',

-          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],

-         'C',

-         'D',

-         ['def',

-          'spam',

-          ['(', 'x', 'y', ')'],

-          ':',

-          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 

-    """

-    def checkPeerIndent(s,l,t):

-        if l >= len(s): return

-        curCol = col(l,s)

-        if curCol != indentStack[-1]:

-            if curCol > indentStack[-1]:

-                raise ParseFatalException(s,l,"illegal nesting")

-            raise ParseException(s,l,"not a peer entry")

-

-    def checkSubIndent(s,l,t):

-        curCol = col(l,s)

-        if curCol > indentStack[-1]:

-            indentStack.append( curCol )

-        else:

-            raise ParseException(s,l,"not a subentry")

-

-    def checkUnindent(s,l,t):

-        if l >= len(s): return

-        curCol = col(l,s)

-        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):

-            raise ParseException(s,l,"not an unindent")

-        indentStack.pop()

-

-    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())

-    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')

-    PEER   = Empty().setParseAction(checkPeerIndent).setName('')

-    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')

-    if indent:

-        smExpr = Group( Optional(NL) +

-            #~ FollowedBy(blockStatementExpr) +

-            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)

-    else:

-        smExpr = Group( Optional(NL) +

-            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )

-    blockStatementExpr.ignore(_bslash + LineEnd())

-    return smExpr.setName('indented block')

-

-alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")

-punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")

-

-anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))

-_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))

-commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")

-def replaceHTMLEntity(t):

-    """Helper parser action to replace common HTML entities with their special characters"""

-    return _htmlEntityMap.get(t.entity)

-

-# it's easy to get these comment structures wrong - they're very common, so may as well make them available

-cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")

-"Comment of the form C{/* ... */}"

-

-htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment")

-"Comment of the form C{<!-- ... -->}"

-

-restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")

-dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")

-"Comment of the form C{// ... (to end of line)}"

-

-cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")

-"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"

-

-javaStyleComment = cppStyleComment

-"Same as C{L{cppStyleComment}}"

-

-pythonStyleComment = Regex(r"#.*").setName("Python style comment")

-"Comment of the form C{# ... (to end of line)}"

-

-_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +

-                                  Optional( Word(" \t") +

-                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")

-commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")

-"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.

-   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""

-

-# some other useful expressions - using lower-case class name since we are really using this as a namespace

-class pyparsing_common:

-    """

-    Here are some common low-level expressions that may be useful in jump-starting parser development:

-     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>})

-     - common L{programming identifiers<identifier>}

-     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>})

-     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>}

-     - L{UUID<uuid>}

-     - L{comma-separated list<comma_separated_list>}

-    Parse actions:

-     - C{L{convertToInteger}}

-     - C{L{convertToFloat}}

-     - C{L{convertToDate}}

-     - C{L{convertToDatetime}}

-     - C{L{stripHTMLTags}}

-     - C{L{upcaseTokens}}

-     - C{L{downcaseTokens}}

-

-    Example::

-        pyparsing_common.number.runTests('''

-            # any int or real number, returned as the appropriate type

-            100

-            -100

-            +100

-            3.14159

-            6.02e23

-            1e-12

-            ''')

-

-        pyparsing_common.fnumber.runTests('''

-            # any int or real number, returned as float

-            100

-            -100

-            +100

-            3.14159

-            6.02e23

-            1e-12

-            ''')

-

-        pyparsing_common.hex_integer.runTests('''

-            # hex numbers

-            100

-            FF

-            ''')

-

-        pyparsing_common.fraction.runTests('''

-            # fractions

-            1/2

-            -3/4

-            ''')

-

-        pyparsing_common.mixed_integer.runTests('''

-            # mixed fractions

-            1

-            1/2

-            -3/4

-            1-3/4

-            ''')

-

-        import uuid

-        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))

-        pyparsing_common.uuid.runTests('''

-            # uuid

-            12345678-1234-5678-1234-567812345678

-            ''')

-    prints::

-        # any int or real number, returned as the appropriate type

-        100

-        [100]

-

-        -100

-        [-100]

-

-        +100

-        [100]

-

-        3.14159

-        [3.14159]

-

-        6.02e23

-        [6.02e+23]

-

-        1e-12

-        [1e-12]

-

-        # any int or real number, returned as float

-        100

-        [100.0]

-

-        -100

-        [-100.0]

-

-        +100

-        [100.0]

-

-        3.14159

-        [3.14159]

-

-        6.02e23

-        [6.02e+23]

-

-        1e-12

-        [1e-12]

-

-        # hex numbers

-        100

-        [256]

-

-        FF

-        [255]

-

-        # fractions

-        1/2

-        [0.5]

-

-        -3/4

-        [-0.75]

-

-        # mixed fractions

-        1

-        [1]

-

-        1/2

-        [0.5]

-

-        -3/4

-        [-0.75]

-

-        1-3/4

-        [1.75]

-

-        # uuid

-        12345678-1234-5678-1234-567812345678

-        [UUID('12345678-1234-5678-1234-567812345678')]

-    """

-

-    convertToInteger = tokenMap(int)

-    """

-    Parse action for converting parsed integers to Python int

-    """

-

-    convertToFloat = tokenMap(float)

-    """

-    Parse action for converting parsed numbers to Python float

-    """

-

-    integer = Word(nums).setName("integer").setParseAction(convertToInteger)

-    """expression that parses an unsigned integer, returns an int"""

-

-    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))

-    """expression that parses a hexadecimal integer, returns an int"""

-

-    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)

-    """expression that parses an integer with optional leading sign, returns an int"""

-

-    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")

-    """fractional expression of an integer divided by an integer, returns a float"""

-    fraction.addParseAction(lambda t: t[0]/t[-1])

-

-    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")

-    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""

-    mixed_integer.addParseAction(sum)

-

-    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)

-    """expression that parses a floating point number and returns a float"""

-

-    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)

-    """expression that parses a floating point number with optional scientific notation and returns a float"""

-

-    # streamlining this expression makes the docs nicer-looking

-    number = (sci_real | real | signed_integer).streamline()

-    """any numeric expression, returns the corresponding Python type"""

-

-    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)

-    """any int or real number, returned as float"""

-    

-    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")

-    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""

-    

-    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")

-    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"

-

-    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")

-    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")

-    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")

-    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)

-    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")

-    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")

-    "IPv6 address (long, short, or mixed form)"

-    

-    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")

-    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"

-

-    @staticmethod

-    def convertToDate(fmt="%Y-%m-%d"):

-        """

-        Helper to create a parse action for converting parsed date string to Python datetime.date

-

-        Params -

-         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})

-

-        Example::

-            date_expr = pyparsing_common.iso8601_date.copy()

-            date_expr.setParseAction(pyparsing_common.convertToDate())

-            print(date_expr.parseString("1999-12-31"))

-        prints::

-            [datetime.date(1999, 12, 31)]

-        """

-        def cvt_fn(s,l,t):

-            try:

-                return datetime.strptime(t[0], fmt).date()

-            except ValueError as ve:

-                raise ParseException(s, l, str(ve))

-        return cvt_fn

-

-    @staticmethod

-    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):

-        """

-        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime

-

-        Params -

-         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})

-

-        Example::

-            dt_expr = pyparsing_common.iso8601_datetime.copy()

-            dt_expr.setParseAction(pyparsing_common.convertToDatetime())

-            print(dt_expr.parseString("1999-12-31T23:59:59.999"))

-        prints::

-            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]

-        """

-        def cvt_fn(s,l,t):

-            try:

-                return datetime.strptime(t[0], fmt)

-            except ValueError as ve:

-                raise ParseException(s, l, str(ve))

-        return cvt_fn

-

-    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date")

-    "ISO8601 date (C{yyyy-mm-dd})"

-

-    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")

-    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"

-

-    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")

-    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"

-

-    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()

-    @staticmethod

-    def stripHTMLTags(s, l, tokens):

-        """

-        Parse action to remove HTML tags from web page HTML source

-

-        Example::

-            # strip HTML links from normal text 

-            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'

-            td,td_end = makeHTMLTags("TD")

-            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end

-            

-            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'

-        """

-        return pyparsing_common._html_stripper.transformString(tokens[0])

-

-    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 

-                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")

-    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")

-    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""

-

-    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))

-    """Parse action to convert tokens to upper case."""

-

-    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))

-    """Parse action to convert tokens to lower case."""

-

-

-if __name__ == "__main__":

-

-    selectToken    = CaselessLiteral("select")

-    fromToken      = CaselessLiteral("from")

-

-    ident          = Word(alphas, alphanums + "_$")

-

-    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)

-    columnNameList = Group(delimitedList(columnName)).setName("columns")

-    columnSpec     = ('*' | columnNameList)

-

-    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)

-    tableNameList  = Group(delimitedList(tableName)).setName("tables")

-    

-    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")

-

-    # demo runTests method, including embedded comments in test string

-    simpleSQL.runTests("""

-        # '*' as column list and dotted table name

-        select * from SYS.XYZZY

-

-        # caseless match on "SELECT", and casts back to "select"

-        SELECT * from XYZZY, ABC

-

-        # list of column names, and mixed case SELECT keyword

-        Select AA,BB,CC from Sys.dual

-

-        # multiple tables

-        Select A, B, C from Sys.dual, Table2

-

-        # invalid SELECT keyword - should fail

-        Xelect A, B, C from Sys.dual

-

-        # incomplete command - should fail

-        Select

-

-        # invalid column name - should fail

-        Select ^^^ frox Sys.dual

-

-        """)

-

-    pyparsing_common.number.runTests("""

-        100

-        -100

-        +100

-        3.14159

-        6.02e23

-        1e-12

-        """)

-

-    # any int or real number, returned as float

-    pyparsing_common.fnumber.runTests("""

-        100

-        -100

-        +100

-        3.14159

-        6.02e23

-        1e-12

-        """)

-

-    pyparsing_common.hex_integer.runTests("""

-        100

-        FF

-        """)

-

-    import uuid

-    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))

-    pyparsing_common.uuid.runTests("""

-        12345678-1234-5678-1234-567812345678

-        """)

+# module pyparsing.py 
+# 
+# Copyright (c) 2003-2018  Paul T. McGuire 
+# 
+# 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. 
+# 
+ 
+__doc__ = \ 
+""" 
+pyparsing module - Classes and methods to define and execute parsing grammars 
+============================================================================= 
+ 
+The pyparsing module is an alternative approach to creating and executing simple grammars, 
+vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you 
+don't need to learn a new syntax for defining grammars or matching expressions - the parsing module 
+provides a library of classes that you use to construct the grammar directly in Python. 
+ 
+Here is a program to parse "Hello, World!" (or any greeting of the form  
+C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements  
+(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to 
+L{Literal} expressions):: 
+ 
+    from pyparsing import Word, alphas 
+ 
+    # define grammar of a greeting 
+    greet = Word(alphas) + "," + Word(alphas) + "!" 
+ 
+    hello = "Hello, World!" 
+    print (hello, "->", greet.parseString(hello)) 
+ 
+The program outputs the following:: 
+ 
+    Hello, World! -> ['Hello', ',', 'World', '!'] 
+ 
+The Python representation of the grammar is quite readable, owing to the self-explanatory 
+class names, and the use of '+', '|' and '^' operators. 
+ 
+The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an 
+object with named attributes. 
+ 
+The pyparsing module handles some of the problems that are typically vexing when writing text parsers: 
+ - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.) 
+ - quoted strings 
+ - embedded comments 
+ 
+ 
+Getting Started - 
+----------------- 
+Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing 
+classes inherit from. Use the docstrings for examples of how to: 
+ - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes 
+ - construct character word-group expressions using the L{Word} class 
+ - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes 
+ - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones 
+ - associate names with your parsed results using L{ParserElement.setResultsName} 
+ - find some helpful expression short-cuts like L{delimitedList} and L{oneOf} 
+ - find more useful common expressions in the L{pyparsing_common} namespace class 
+""" 
+ 
+__version__ = "2.2.1" 
+__versionTime__ = "18 Sep 2018 00:49 UTC" 
+__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>" 
+ 
+import string 
+from weakref import ref as wkref 
+import copy 
+import sys 
+import warnings 
+import re 
+import sre_constants 
+import collections 
+import pprint 
+import traceback 
+import types 
+from datetime import datetime 
+ 
+try: 
+    from _thread import RLock 
+except ImportError: 
+    from threading import RLock 
+ 
+try: 
+    # Python 3 
+    from collections.abc import Iterable 
+    from collections.abc import MutableMapping 
+except ImportError: 
+    # Python 2.7 
+    from collections import Iterable 
+    from collections import MutableMapping 
+ 
+try: 
+    from collections import OrderedDict as _OrderedDict 
+except ImportError: 
+    try: 
+        from ordereddict import OrderedDict as _OrderedDict 
+    except ImportError: 
+        _OrderedDict = None 
+ 
+#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) ) 
+ 
+__all__ = [ 
+'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty', 
+'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal', 
+'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or', 
+'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException', 
+'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException', 
+'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter',  
+'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore', 
+'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col', 
+'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString', 
+'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums', 
+'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno', 
+'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral', 
+'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables', 
+'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity',  
+'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd', 
+'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute', 
+'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass', 
+'CloseMatch', 'tokenMap', 'pyparsing_common', 
+] 
+ 
+system_version = tuple(sys.version_info)[:3] 
+PY_3 = system_version[0] == 3 
+if PY_3: 
+    _MAX_INT = sys.maxsize 
+    basestring = str 
+    unichr = chr 
+    _ustr = str 
+ 
+    # build list of single arg builtins, that can be used as parse actions 
+    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max] 
+ 
+else: 
+    _MAX_INT = sys.maxint 
+    range = xrange 
+ 
+    def _ustr(obj): 
+        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries 
+           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It 
+           then < returns the unicode object | encodes it with the default encoding | ... >. 
+        """ 
+        if isinstance(obj,unicode): 
+            return obj 
+ 
+        try: 
+            # If this works, then _ustr(obj) has the same behaviour as str(obj), so 
+            # it won't break any existing code. 
+            return str(obj) 
+ 
+        except UnicodeEncodeError: 
+            # Else encode it 
+            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace') 
+            xmlcharref = Regex(r'&#\d+;') 
+            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:]) 
+            return xmlcharref.transformString(ret) 
+ 
+    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions 
+    singleArgBuiltins = [] 
+    import __builtin__ 
+    for fname in "sum len sorted reversed list tuple set any all min max".split(): 
+        try: 
+            singleArgBuiltins.append(getattr(__builtin__,fname)) 
+        except AttributeError: 
+            continue 
+             
+_generatorType = type((y for y in range(1))) 
+  
+def _xml_escape(data): 
+    """Escape &, <, >, ", ', etc. in a string of data.""" 
+ 
+    # ampersand must be replaced first 
+    from_symbols = '&><"\'' 
+    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split()) 
+    for from_,to_ in zip(from_symbols, to_symbols): 
+        data = data.replace(from_, to_) 
+    return data 
+ 
+class _Constants(object): 
+    pass 
+ 
+alphas     = string.ascii_uppercase + string.ascii_lowercase 
+nums       = "0123456789" 
+hexnums    = nums + "ABCDEFabcdef" 
+alphanums  = alphas + nums 
+_bslash    = chr(92) 
+printables = "".join(c for c in string.printable if c not in string.whitespace) 
+ 
+class ParseBaseException(Exception): 
+    """base exception class for all parsing runtime exceptions""" 
+    # Performance tuning: we construct a *lot* of these, so keep this 
+    # constructor as small and fast as possible 
+    def __init__( self, pstr, loc=0, msg=None, elem=None ): 
+        self.loc = loc 
+        if msg is None: 
+            self.msg = pstr 
+            self.pstr = "" 
+        else: 
+            self.msg = msg 
+            self.pstr = pstr 
+        self.parserElement = elem 
+        self.args = (pstr, loc, msg) 
+ 
+    @classmethod 
+    def _from_exception(cls, pe): 
+        """ 
+        internal factory method to simplify creating one type of ParseException  
+        from another - avoids having __init__ signature conflicts among subclasses 
+        """ 
+        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement) 
+ 
+    def __getattr__( self, aname ): 
+        """supported attributes by name are: 
+            - lineno - returns the line number of the exception text 
+            - col - returns the column number of the exception text 
+            - line - returns the line containing the exception text 
+        """ 
+        if( aname == "lineno" ): 
+            return lineno( self.loc, self.pstr ) 
+        elif( aname in ("col", "column") ): 
+            return col( self.loc, self.pstr ) 
+        elif( aname == "line" ): 
+            return line( self.loc, self.pstr ) 
+        else: 
+            raise AttributeError(aname) 
+ 
+    def __str__( self ): 
+        return "%s (at char %d), (line:%d, col:%d)" % \ 
+                ( self.msg, self.loc, self.lineno, self.column ) 
+    def __repr__( self ): 
+        return _ustr(self) 
+    def markInputline( self, markerString = ">!<" ): 
+        """Extracts the exception line from the input string, and marks 
+           the location of the exception with a special symbol. 
+        """ 
+        line_str = self.line 
+        line_column = self.column - 1 
+        if markerString: 
+            line_str = "".join((line_str[:line_column], 
+                                markerString, line_str[line_column:])) 
+        return line_str.strip() 
+    def __dir__(self): 
+        return "lineno col line".split() + dir(type(self)) 
+ 
+class ParseException(ParseBaseException): 
+    """ 
+    Exception thrown when parse expressions don't match class; 
+    supported attributes by name are: 
+     - lineno - returns the line number of the exception text 
+     - col - returns the column number of the exception text 
+     - line - returns the line containing the exception text 
+         
+    Example:: 
+        try: 
+            Word(nums).setName("integer").parseString("ABC") 
+        except ParseException as pe: 
+            print(pe) 
+            print("column: {}".format(pe.col)) 
+             
+    prints:: 
+       Expected integer (at char 0), (line:1, col:1) 
+        column: 1 
+    """ 
+    pass 
+ 
+class ParseFatalException(ParseBaseException): 
+    """user-throwable exception thrown when inconsistent parse content 
+       is found; stops all parsing immediately""" 
+    pass 
+ 
+class ParseSyntaxException(ParseFatalException): 
+    """just like L{ParseFatalException}, but thrown internally when an 
+       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop  
+       immediately because an unbacktrackable syntax error has been found""" 
+    pass 
+ 
+#~ class ReparseException(ParseBaseException): 
+    #~ """Experimental class - parse actions can raise this exception to cause 
+       #~ pyparsing to reparse the input string: 
+        #~ - with a modified input string, and/or 
+        #~ - with a modified start location 
+       #~ Set the values of the ReparseException in the constructor, and raise the 
+       #~ exception in a parse action to cause pyparsing to use the new string/location. 
+       #~ Setting the values as None causes no change to be made. 
+       #~ """ 
+    #~ def __init_( self, newstring, restartLoc ): 
+        #~ self.newParseText = newstring 
+        #~ self.reparseLoc = restartLoc 
+ 
+class RecursiveGrammarException(Exception): 
+    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive""" 
+    def __init__( self, parseElementList ): 
+        self.parseElementTrace = parseElementList 
+ 
+    def __str__( self ): 
+        return "RecursiveGrammarException: %s" % self.parseElementTrace 
+ 
+class _ParseResultsWithOffset(object): 
+    def __init__(self,p1,p2): 
+        self.tup = (p1,p2) 
+    def __getitem__(self,i): 
+        return self.tup[i] 
+    def __repr__(self): 
+        return repr(self.tup[0]) 
+    def setOffset(self,i): 
+        self.tup = (self.tup[0],i) 
+ 
+class ParseResults(object): 
+    """ 
+    Structured parse results, to provide multiple means of access to the parsed data: 
+       - as a list (C{len(results)}) 
+       - by list index (C{results[0], results[1]}, etc.) 
+       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName}) 
+ 
+    Example:: 
+        integer = Word(nums) 
+        date_str = (integer.setResultsName("year") + '/'  
+                        + integer.setResultsName("month") + '/'  
+                        + integer.setResultsName("day")) 
+        # equivalent form: 
+        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+ 
+        # parseString returns a ParseResults object 
+        result = date_str.parseString("1999/12/31") 
+ 
+        def test(s, fn=repr): 
+            print("%s -> %s" % (s, fn(eval(s)))) 
+        test("list(result)") 
+        test("result[0]") 
+        test("result['month']") 
+        test("result.day") 
+        test("'month' in result") 
+        test("'minutes' in result") 
+        test("result.dump()", str) 
+    prints:: 
+        list(result) -> ['1999', '/', '12', '/', '31'] 
+        result[0] -> '1999' 
+        result['month'] -> '12' 
+        result.day -> '31' 
+        'month' in result -> True 
+        'minutes' in result -> False 
+        result.dump() -> ['1999', '/', '12', '/', '31'] 
+        - day: 31 
+        - month: 12 
+        - year: 1999 
+    """ 
+    def __new__(cls, toklist=None, name=None, asList=True, modal=True ): 
+        if isinstance(toklist, cls): 
+            return toklist 
+        retobj = object.__new__(cls) 
+        retobj.__doinit = True 
+        return retobj 
+ 
+    # Performance tuning: we construct a *lot* of these, so keep this 
+    # constructor as small and fast as possible 
+    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ): 
+        if self.__doinit: 
+            self.__doinit = False 
+            self.__name = None 
+            self.__parent = None 
+            self.__accumNames = {} 
+            self.__asList = asList 
+            self.__modal = modal 
+            if toklist is None: 
+                toklist = [] 
+            if isinstance(toklist, list): 
+                self.__toklist = toklist[:] 
+            elif isinstance(toklist, _generatorType): 
+                self.__toklist = list(toklist) 
+            else: 
+                self.__toklist = [toklist] 
+            self.__tokdict = dict() 
+ 
+        if name is not None and name: 
+            if not modal: 
+                self.__accumNames[name] = 0 
+            if isinstance(name,int): 
+                name = _ustr(name) # will always return a str, but use _ustr for consistency 
+            self.__name = name 
+            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])): 
+                if isinstance(toklist,basestring): 
+                    toklist = [ toklist ] 
+                if asList: 
+                    if isinstance(toklist,ParseResults): 
+                        self[name] = _ParseResultsWithOffset(toklist.copy(),0) 
+                    else: 
+                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0) 
+                    self[name].__name = name 
+                else: 
+                    try: 
+                        self[name] = toklist[0] 
+                    except (KeyError,TypeError,IndexError): 
+                        self[name] = toklist 
+ 
+    def __getitem__( self, i ): 
+        if isinstance( i, (int,slice) ): 
+            return self.__toklist[i] 
+        else: 
+            if i not in self.__accumNames: 
+                return self.__tokdict[i][-1][0] 
+            else: 
+                return ParseResults([ v[0] for v in self.__tokdict[i] ]) 
+ 
+    def __setitem__( self, k, v, isinstance=isinstance ): 
+        if isinstance(v,_ParseResultsWithOffset): 
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v] 
+            sub = v[0] 
+        elif isinstance(k,(int,slice)): 
+            self.__toklist[k] = v 
+            sub = v 
+        else: 
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)] 
+            sub = v 
+        if isinstance(sub,ParseResults): 
+            sub.__parent = wkref(self) 
+ 
+    def __delitem__( self, i ): 
+        if isinstance(i,(int,slice)): 
+            mylen = len( self.__toklist ) 
+            del self.__toklist[i] 
+ 
+            # convert int to slice 
+            if isinstance(i, int): 
+                if i < 0: 
+                    i += mylen 
+                i = slice(i, i+1) 
+            # get removed indices 
+            removed = list(range(*i.indices(mylen))) 
+            removed.reverse() 
+            # fixup indices in token dictionary 
+            for name,occurrences in self.__tokdict.items(): 
+                for j in removed: 
+                    for k, (value, position) in enumerate(occurrences): 
+                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j)) 
+        else: 
+            del self.__tokdict[i] 
+ 
+    def __contains__( self, k ): 
+        return k in self.__tokdict 
+ 
+    def __len__( self ): return len( self.__toklist ) 
+    def __bool__(self): return ( not not self.__toklist ) 
+    __nonzero__ = __bool__ 
+    def __iter__( self ): return iter( self.__toklist ) 
+    def __reversed__( self ): return iter( self.__toklist[::-1] ) 
+    def _iterkeys( self ): 
+        if hasattr(self.__tokdict, "iterkeys"): 
+            return self.__tokdict.iterkeys() 
+        else: 
+            return iter(self.__tokdict) 
+ 
+    def _itervalues( self ): 
+        return (self[k] for k in self._iterkeys()) 
+             
+    def _iteritems( self ): 
+        return ((k, self[k]) for k in self._iterkeys()) 
+ 
+    if PY_3: 
+        keys = _iterkeys        
+        """Returns an iterator of all named result keys (Python 3.x only).""" 
+ 
+        values = _itervalues 
+        """Returns an iterator of all named result values (Python 3.x only).""" 
+ 
+        items = _iteritems 
+        """Returns an iterator of all named result key-value tuples (Python 3.x only).""" 
+ 
+    else: 
+        iterkeys = _iterkeys 
+        """Returns an iterator of all named result keys (Python 2.x only).""" 
+ 
+        itervalues = _itervalues 
+        """Returns an iterator of all named result values (Python 2.x only).""" 
+ 
+        iteritems = _iteritems 
+        """Returns an iterator of all named result key-value tuples (Python 2.x only).""" 
+ 
+        def keys( self ): 
+            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x).""" 
+            return list(self.iterkeys()) 
+ 
+        def values( self ): 
+            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x).""" 
+            return list(self.itervalues()) 
+                 
+        def items( self ): 
+            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x).""" 
+            return list(self.iteritems()) 
+ 
+    def haskeys( self ): 
+        """Since keys() returns an iterator, this method is helpful in bypassing 
+           code that looks for the existence of any defined results names.""" 
+        return bool(self.__tokdict) 
+         
+    def pop( self, *args, **kwargs): 
+        """ 
+        Removes and returns item at specified index (default=C{last}). 
+        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no 
+        argument or an integer argument, it will use C{list} semantics 
+        and pop tokens from the list of parsed tokens. If passed a  
+        non-integer argument (most likely a string), it will use C{dict} 
+        semantics and pop the corresponding value from any defined  
+        results names. A second default return value argument is  
+        supported, just as in C{dict.pop()}. 
+ 
+        Example:: 
+            def remove_first(tokens): 
+                tokens.pop(0) 
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321'] 
+            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321'] 
+ 
+            label = Word(alphas) 
+            patt = label("LABEL") + OneOrMore(Word(nums)) 
+            print(patt.parseString("AAB 123 321").dump()) 
+ 
+            # Use pop() in a parse action to remove named result (note that corresponding value is not 
+            # removed from list form of results) 
+            def remove_LABEL(tokens): 
+                tokens.pop("LABEL") 
+                return tokens 
+            patt.addParseAction(remove_LABEL) 
+            print(patt.parseString("AAB 123 321").dump()) 
+        prints:: 
+            ['AAB', '123', '321'] 
+            - LABEL: AAB 
+ 
+            ['AAB', '123', '321'] 
+        """ 
+        if not args: 
+            args = [-1] 
+        for k,v in kwargs.items(): 
+            if k == 'default': 
+                args = (args[0], v) 
+            else: 
+                raise TypeError("pop() got an unexpected keyword argument '%s'" % k) 
+        if (isinstance(args[0], int) or  
+                        len(args) == 1 or  
+                        args[0] in self): 
+            index = args[0] 
+            ret = self[index] 
+            del self[index] 
+            return ret 
+        else: 
+            defaultvalue = args[1] 
+            return defaultvalue 
+ 
+    def get(self, key, defaultValue=None): 
+        """ 
+        Returns named result matching the given key, or if there is no 
+        such name, then returns the given C{defaultValue} or C{None} if no 
+        C{defaultValue} is specified. 
+ 
+        Similar to C{dict.get()}. 
+         
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")            
+ 
+            result = date_str.parseString("1999/12/31") 
+            print(result.get("year")) # -> '1999' 
+            print(result.get("hour", "not specified")) # -> 'not specified' 
+            print(result.get("hour")) # -> None 
+        """ 
+        if key in self: 
+            return self[key] 
+        else: 
+            return defaultValue 
+ 
+    def insert( self, index, insStr ): 
+        """ 
+        Inserts new element at location index in the list of parsed tokens. 
+         
+        Similar to C{list.insert()}. 
+ 
+        Example:: 
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321'] 
+ 
+            # use a parse action to insert the parse location in the front of the parsed results 
+            def insert_locn(locn, tokens): 
+                tokens.insert(0, locn) 
+            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321'] 
+        """ 
+        self.__toklist.insert(index, insStr) 
+        # fixup indices in token dictionary 
+        for name,occurrences in self.__tokdict.items(): 
+            for k, (value, position) in enumerate(occurrences): 
+                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index)) 
+ 
+    def append( self, item ): 
+        """ 
+        Add single element to end of ParseResults list of elements. 
+ 
+        Example:: 
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321'] 
+             
+            # use a parse action to compute the sum of the parsed integers, and add it to the end 
+            def append_sum(tokens): 
+                tokens.append(sum(map(int, tokens))) 
+            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444] 
+        """ 
+        self.__toklist.append(item) 
+ 
+    def extend( self, itemseq ): 
+        """ 
+        Add sequence of elements to end of ParseResults list of elements. 
+ 
+        Example:: 
+            patt = OneOrMore(Word(alphas)) 
+             
+            # use a parse action to append the reverse of the matched strings, to make a palindrome 
+            def make_palindrome(tokens): 
+                tokens.extend(reversed([t[::-1] for t in tokens])) 
+                return ''.join(tokens) 
+            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl' 
+        """ 
+        if isinstance(itemseq, ParseResults): 
+            self += itemseq 
+        else: 
+            self.__toklist.extend(itemseq) 
+ 
+    def clear( self ): 
+        """ 
+        Clear all elements and results names. 
+        """ 
+        del self.__toklist[:] 
+        self.__tokdict.clear() 
+ 
+    def __getattr__( self, name ): 
+        try: 
+            return self[name] 
+        except KeyError: 
+            return "" 
+             
+        if name in self.__tokdict: 
+            if name not in self.__accumNames: 
+                return self.__tokdict[name][-1][0] 
+            else: 
+                return ParseResults([ v[0] for v in self.__tokdict[name] ]) 
+        else: 
+            return "" 
+ 
+    def __add__( self, other ): 
+        ret = self.copy() 
+        ret += other 
+        return ret 
+ 
+    def __iadd__( self, other ): 
+        if other.__tokdict: 
+            offset = len(self.__toklist) 
+            addoffset = lambda a: offset if a<0 else a+offset 
+            otheritems = other.__tokdict.items() 
+            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) ) 
+                                for (k,vlist) in otheritems for v in vlist] 
+            for k,v in otherdictitems: 
+                self[k] = v 
+                if isinstance(v[0],ParseResults): 
+                    v[0].__parent = wkref(self) 
+             
+        self.__toklist += other.__toklist 
+        self.__accumNames.update( other.__accumNames ) 
+        return self 
+ 
+    def __radd__(self, other): 
+        if isinstance(other,int) and other == 0: 
+            # useful for merging many ParseResults using sum() builtin 
+            return self.copy() 
+        else: 
+            # this may raise a TypeError - so be it 
+            return other + self 
+         
+    def __repr__( self ): 
+        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) ) 
+ 
+    def __str__( self ): 
+        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']' 
+ 
+    def _asStringList( self, sep='' ): 
+        out = [] 
+        for item in self.__toklist: 
+            if out and sep: 
+                out.append(sep) 
+            if isinstance( item, ParseResults ): 
+                out += item._asStringList() 
+            else: 
+                out.append( _ustr(item) ) 
+        return out 
+ 
+    def asList( self ): 
+        """ 
+        Returns the parse results as a nested list of matching tokens, all converted to strings. 
+ 
+        Example:: 
+            patt = OneOrMore(Word(alphas)) 
+            result = patt.parseString("sldkj lsdkj sldkj") 
+            # even though the result prints in string-like form, it is actually a pyparsing ParseResults 
+            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj'] 
+             
+            # Use asList() to create an actual list 
+            result_list = result.asList() 
+            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj'] 
+        """ 
+        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist] 
+ 
+    def asDict( self ): 
+        """ 
+        Returns the named parse results as a nested dictionary. 
+ 
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+             
+            result = date_str.parseString('12/31/1999') 
+            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]}) 
+             
+            result_dict = result.asDict() 
+            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'} 
+ 
+            # even though a ParseResults supports dict-like access, sometime you just need to have a dict 
+            import json 
+            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable 
+            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"} 
+        """ 
+        if PY_3: 
+            item_fn = self.items 
+        else: 
+            item_fn = self.iteritems 
+             
+        def toItem(obj): 
+            if isinstance(obj, ParseResults): 
+                if obj.haskeys(): 
+                    return obj.asDict() 
+                else: 
+                    return [toItem(v) for v in obj] 
+            else: 
+                return obj 
+                 
+        return dict((k,toItem(v)) for k,v in item_fn()) 
+ 
+    def copy( self ): 
+        """ 
+        Returns a new copy of a C{ParseResults} object. 
+        """ 
+        ret = ParseResults( self.__toklist ) 
+        ret.__tokdict = self.__tokdict.copy() 
+        ret.__parent = self.__parent 
+        ret.__accumNames.update( self.__accumNames ) 
+        ret.__name = self.__name 
+        return ret 
+ 
+    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ): 
+        """ 
+        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names. 
+        """ 
+        nl = "\n" 
+        out = [] 
+        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items() 
+                                                            for v in vlist) 
+        nextLevelIndent = indent + "  " 
+ 
+        # collapse out indents if formatting is not desired 
+        if not formatted: 
+            indent = "" 
+            nextLevelIndent = "" 
+            nl = "" 
+ 
+        selfTag = None 
+        if doctag is not None: 
+            selfTag = doctag 
+        else: 
+            if self.__name: 
+                selfTag = self.__name 
+ 
+        if not selfTag: 
+            if namedItemsOnly: 
+                return "" 
+            else: 
+                selfTag = "ITEM" 
+ 
+        out += [ nl, indent, "<", selfTag, ">" ] 
+ 
+        for i,res in enumerate(self.__toklist): 
+            if isinstance(res,ParseResults): 
+                if i in namedItems: 
+                    out += [ res.asXML(namedItems[i], 
+                                        namedItemsOnly and doctag is None, 
+                                        nextLevelIndent, 
+                                        formatted)] 
+                else: 
+                    out += [ res.asXML(None, 
+                                        namedItemsOnly and doctag is None, 
+                                        nextLevelIndent, 
+                                        formatted)] 
+            else: 
+                # individual token, see if there is a name for it 
+                resTag = None 
+                if i in namedItems: 
+                    resTag = namedItems[i] 
+                if not resTag: 
+                    if namedItemsOnly: 
+                        continue 
+                    else: 
+                        resTag = "ITEM" 
+                xmlBodyText = _xml_escape(_ustr(res)) 
+                out += [ nl, nextLevelIndent, "<", resTag, ">", 
+                                                xmlBodyText, 
+                                                "</", resTag, ">" ] 
+ 
+        out += [ nl, indent, "</", selfTag, ">" ] 
+        return "".join(out) 
+ 
+    def __lookup(self,sub): 
+        for k,vlist in self.__tokdict.items(): 
+            for v,loc in vlist: 
+                if sub is v: 
+                    return k 
+        return None 
+ 
+    def getName(self): 
+        r""" 
+        Returns the results name for this token expression. Useful when several  
+        different expressions might match at a particular location. 
+ 
+        Example:: 
+            integer = Word(nums) 
+            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d") 
+            house_number_expr = Suppress('#') + Word(nums, alphanums) 
+            user_data = (Group(house_number_expr)("house_number")  
+                        | Group(ssn_expr)("ssn") 
+                        | Group(integer)("age")) 
+            user_info = OneOrMore(user_data) 
+             
+            result = user_info.parseString("22 111-22-3333 #221B") 
+            for item in result: 
+                print(item.getName(), ':', item[0]) 
+        prints:: 
+            age : 22 
+            ssn : 111-22-3333 
+            house_number : 221B 
+        """ 
+        if self.__name: 
+            return self.__name 
+        elif self.__parent: 
+            par = self.__parent() 
+            if par: 
+                return par.__lookup(self) 
+            else: 
+                return None 
+        elif (len(self) == 1 and 
+               len(self.__tokdict) == 1 and 
+               next(iter(self.__tokdict.values()))[0][1] in (0,-1)): 
+            return next(iter(self.__tokdict.keys())) 
+        else: 
+            return None 
+ 
+    def dump(self, indent='', depth=0, full=True): 
+        """ 
+        Diagnostic method for listing out the contents of a C{ParseResults}. 
+        Accepts an optional C{indent} argument so that this string can be embedded 
+        in a nested display of other data. 
+ 
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+             
+            result = date_str.parseString('12/31/1999') 
+            print(result.dump()) 
+        prints:: 
+            ['12', '/', '31', '/', '1999'] 
+            - day: 1999 
+            - month: 31 
+            - year: 12 
+        """ 
+        out = [] 
+        NL = '\n' 
+        out.append( indent+_ustr(self.asList()) ) 
+        if full: 
+            if self.haskeys(): 
+                items = sorted((str(k), v) for k,v in self.items()) 
+                for k,v in items: 
+                    if out: 
+                        out.append(NL) 
+                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) ) 
+                    if isinstance(v,ParseResults): 
+                        if v: 
+                            out.append( v.dump(indent,depth+1) ) 
+                        else: 
+                            out.append(_ustr(v)) 
+                    else: 
+                        out.append(repr(v)) 
+            elif any(isinstance(vv,ParseResults) for vv in self): 
+                v = self 
+                for i,vv in enumerate(v): 
+                    if isinstance(vv,ParseResults): 
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) )) 
+                    else: 
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv))) 
+             
+        return "".join(out) 
+ 
+    def pprint(self, *args, **kwargs): 
+        """ 
+        Pretty-printer for parsed results as a list, using the C{pprint} module. 
+        Accepts additional positional or keyword args as defined for the  
+        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint}) 
+ 
+        Example:: 
+            ident = Word(alphas, alphanums) 
+            num = Word(nums) 
+            func = Forward() 
+            term = ident | num | Group('(' + func + ')') 
+            func <<= ident + Group(Optional(delimitedList(term))) 
+            result = func.parseString("fna a,b,(fnb c,d,200),100") 
+            result.pprint(width=40) 
+        prints:: 
+            ['fna', 
+             ['a', 
+              'b', 
+              ['(', 'fnb', ['c', 'd', '200'], ')'], 
+              '100']] 
+        """ 
+        pprint.pprint(self.asList(), *args, **kwargs) 
+ 
+    # add support for pickle protocol 
+    def __getstate__(self): 
+        return ( self.__toklist, 
+                 ( self.__tokdict.copy(), 
+                   self.__parent is not None and self.__parent() or None, 
+                   self.__accumNames, 
+                   self.__name ) ) 
+ 
+    def __setstate__(self,state): 
+        self.__toklist = state[0] 
+        (self.__tokdict, 
+         par, 
+         inAccumNames, 
+         self.__name) = state[1] 
+        self.__accumNames = {} 
+        self.__accumNames.update(inAccumNames) 
+        if par is not None: 
+            self.__parent = wkref(par) 
+        else: 
+            self.__parent = None 
+ 
+    def __getnewargs__(self): 
+        return self.__toklist, self.__name, self.__asList, self.__modal 
+ 
+    def __dir__(self): 
+        return (dir(type(self)) + list(self.keys())) 
+ 
+MutableMapping.register(ParseResults) 
+ 
+def col (loc,strg): 
+    """Returns current column within a string, counting newlines as line separators. 
+   The first column is number 1. 
+ 
+   Note: the default parsing behavior is to expand tabs in the input string 
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information 
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a 
+   consistent view of the parsed string, the parse location, and line and column 
+   positions within the parsed string. 
+   """ 
+    s = strg 
+    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc) 
+ 
+def lineno(loc,strg): 
+    """Returns current line number within a string, counting newlines as line separators. 
+   The first line is number 1. 
+ 
+   Note: the default parsing behavior is to expand tabs in the input string 
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information 
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a 
+   consistent view of the parsed string, the parse location, and line and column 
+   positions within the parsed string. 
+   """ 
+    return strg.count("\n",0,loc) + 1 
+ 
+def line( loc, strg ): 
+    """Returns the line of text containing loc within a string, counting newlines as line separators. 
+       """ 
+    lastCR = strg.rfind("\n", 0, loc) 
+    nextCR = strg.find("\n", loc) 
+    if nextCR >= 0: 
+        return strg[lastCR+1:nextCR] 
+    else: 
+        return strg[lastCR+1:] 
+ 
+def _defaultStartDebugAction( instring, loc, expr ): 
+    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))) 
+ 
+def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ): 
+    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList())) 
+ 
+def _defaultExceptionDebugAction( instring, loc, expr, exc ): 
+    print ("Exception raised:" + _ustr(exc)) 
+ 
+def nullDebugAction(*args): 
+    """'Do-nothing' debug action, to suppress debugging output during parsing.""" 
+    pass 
+ 
+# Only works on Python 3.x - nonlocal is toxic to Python 2 installs 
+#~ 'decorator to trim function calls to match the arity of the target' 
+#~ def _trim_arity(func, maxargs=3): 
+    #~ if func in singleArgBuiltins: 
+        #~ return lambda s,l,t: func(t) 
+    #~ limit = 0 
+    #~ foundArity = False 
+    #~ def wrapper(*args): 
+        #~ nonlocal limit,foundArity 
+        #~ while 1: 
+            #~ try: 
+                #~ ret = func(*args[limit:]) 
+                #~ foundArity = True 
+                #~ return ret 
+            #~ except TypeError: 
+                #~ if limit == maxargs or foundArity: 
+                    #~ raise 
+                #~ limit += 1 
+                #~ continue 
+    #~ return wrapper 
+ 
+# this version is Python 2.x-3.x cross-compatible 
+'decorator to trim function calls to match the arity of the target' 
+def _trim_arity(func, maxargs=2): 
+    if func in singleArgBuiltins: 
+        return lambda s,l,t: func(t) 
+    limit = [0] 
+    foundArity = [False] 
+     
+    # traceback return data structure changed in Py3.5 - normalize back to plain tuples 
+    if system_version[:2] >= (3,5): 
+        def extract_stack(limit=0): 
+            # special handling for Python 3.5.0 - extra deep call stack by 1 
+            offset = -3 if system_version == (3,5,0) else -2 
+            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset] 
+            return [frame_summary[:2]] 
+        def extract_tb(tb, limit=0): 
+            frames = traceback.extract_tb(tb, limit=limit) 
+            frame_summary = frames[-1] 
+            return [frame_summary[:2]] 
+    else: 
+        extract_stack = traceback.extract_stack 
+        extract_tb = traceback.extract_tb 
+     
+    # synthesize what would be returned by traceback.extract_stack at the call to  
+    # user's parse action 'func', so that we don't incur call penalty at parse time 
+     
+    LINE_DIFF = 6 
+    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND  
+    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!! 
+    this_line = extract_stack(limit=2)[-1] 
+    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF) 
+ 
+    def wrapper(*args): 
+        while 1: 
+            try: 
+                ret = func(*args[limit[0]:]) 
+                foundArity[0] = True 
+                return ret 
+            except TypeError: 
+                # re-raise TypeErrors if they did not come from our arity testing 
+                if foundArity[0]: 
+                    raise 
+                else: 
+                    try: 
+                        tb = sys.exc_info()[-1] 
+                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth: 
+                            raise 
+                    finally: 
+                        del tb 
+ 
+                if limit[0] <= maxargs: 
+                    limit[0] += 1 
+                    continue 
+                raise 
+ 
+    # copy func name to wrapper for sensible debug output 
+    func_name = "<parse action>" 
+    try: 
+        func_name = getattr(func, '__name__',  
+                            getattr(func, '__class__').__name__) 
+    except Exception: 
+        func_name = str(func) 
+    wrapper.__name__ = func_name 
+ 
+    return wrapper 
+ 
+class ParserElement(object): 
+    """Abstract base level parser element class.""" 
+    DEFAULT_WHITE_CHARS = " \n\t\r" 
+    verbose_stacktrace = False 
+ 
+    @staticmethod 
+    def setDefaultWhitespaceChars( chars ): 
+        r""" 
+        Overrides the default whitespace chars 
+ 
+        Example:: 
+            # default whitespace chars are space, <TAB> and newline 
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl'] 
+             
+            # change to just treat newline as significant 
+            ParserElement.setDefaultWhitespaceChars(" \t") 
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def'] 
+        """ 
+        ParserElement.DEFAULT_WHITE_CHARS = chars 
+ 
+    @staticmethod 
+    def inlineLiteralsUsing(cls): 
+        """ 
+        Set class to be used for inclusion of string literals into a parser. 
+         
+        Example:: 
+            # default literal class used is Literal 
+            integer = Word(nums) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")            
+ 
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31'] 
+ 
+ 
+            # change to Suppress 
+            ParserElement.inlineLiteralsUsing(Suppress) 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")            
+ 
+            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31'] 
+        """ 
+        ParserElement._literalStringClass = cls 
+ 
+    def __init__( self, savelist=False ): 
+        self.parseAction = list() 
+        self.failAction = None 
+        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall 
+        self.strRepr = None 
+        self.resultsName = None 
+        self.saveAsList = savelist 
+        self.skipWhitespace = True 
+        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS 
+        self.copyDefaultWhiteChars = True 
+        self.mayReturnEmpty = False # used when checking for left-recursion 
+        self.keepTabs = False 
+        self.ignoreExprs = list() 
+        self.debug = False 
+        self.streamlined = False 
+        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index 
+        self.errmsg = "" 
+        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all) 
+        self.debugActions = ( None, None, None ) #custom debug actions 
+        self.re = None 
+        self.callPreparse = True # used to avoid redundant calls to preParse 
+        self.callDuringTry = False 
+ 
+    def copy( self ): 
+        """ 
+        Make a copy of this C{ParserElement}.  Useful for defining different parse actions 
+        for the same parsing pattern, using copies of the original parse element. 
+         
+        Example:: 
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K") 
+            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M") 
+             
+            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M")) 
+        prints:: 
+            [5120, 100, 655360, 268435456] 
+        Equivalent form of C{expr.copy()} is just C{expr()}:: 
+            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M") 
+        """ 
+        cpy = copy.copy( self ) 
+        cpy.parseAction = self.parseAction[:] 
+        cpy.ignoreExprs = self.ignoreExprs[:] 
+        if self.copyDefaultWhiteChars: 
+            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS 
+        return cpy 
+ 
+    def setName( self, name ): 
+        """ 
+        Define name for this expression, makes debugging and exception messages clearer. 
+         
+        Example:: 
+            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1) 
+            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1) 
+        """ 
+        self.name = name 
+        self.errmsg = "Expected " + self.name 
+        if hasattr(self,"exception"): 
+            self.exception.msg = self.errmsg 
+        return self 
+ 
+    def setResultsName( self, name, listAllMatches=False ): 
+        """ 
+        Define name for referencing matching tokens as a nested attribute 
+        of the returned parse results. 
+        NOTE: this returns a *copy* of the original C{ParserElement} object; 
+        this is so that the client can define a basic element, such as an 
+        integer, and reference it in multiple places with different names. 
+ 
+        You can also set results names using the abbreviated syntax, 
+        C{expr("name")} in place of C{expr.setResultsName("name")} -  
+        see L{I{__call__}<__call__>}. 
+ 
+        Example:: 
+            date_str = (integer.setResultsName("year") + '/'  
+                        + integer.setResultsName("month") + '/'  
+                        + integer.setResultsName("day")) 
+ 
+            # equivalent form: 
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day") 
+        """ 
+        newself = self.copy() 
+        if name.endswith("*"): 
+            name = name[:-1] 
+            listAllMatches=True 
+        newself.resultsName = name 
+        newself.modalResults = not listAllMatches 
+        return newself 
+ 
+    def setBreak(self,breakFlag = True): 
+        """Method to invoke the Python pdb debugger when this element is 
+           about to be parsed. Set C{breakFlag} to True to enable, False to 
+           disable. 
+        """ 
+        if breakFlag: 
+            _parseMethod = self._parse 
+            def breaker(instring, loc, doActions=True, callPreParse=True): 
+                import pdb 
+                pdb.set_trace() 
+                return _parseMethod( instring, loc, doActions, callPreParse ) 
+            breaker._originalParseMethod = _parseMethod 
+            self._parse = breaker 
+        else: 
+            if hasattr(self._parse,"_originalParseMethod"): 
+                self._parse = self._parse._originalParseMethod 
+        return self 
+ 
+    def setParseAction( self, *fns, **kwargs ): 
+        """ 
+        Define one or more actions to perform when successfully matching parse element definition. 
+        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)}, 
+        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where: 
+         - s   = the original string being parsed (see note below) 
+         - loc = the location of the matching substring 
+         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object 
+        If the functions in fns modify the tokens, they can return them as the return 
+        value from fn, and the modified list of tokens will replace the original. 
+        Otherwise, fn does not need to return any value. 
+ 
+        Optional keyword arguments: 
+         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing 
+ 
+        Note: the default parsing behavior is to expand tabs in the input string 
+        before starting the parsing process.  See L{I{parseString}<parseString>} for more information 
+        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a 
+        consistent view of the parsed string, the parse location, and line and column 
+        positions within the parsed string. 
+         
+        Example:: 
+            integer = Word(nums) 
+            date_str = integer + '/' + integer + '/' + integer 
+ 
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31'] 
+ 
+            # use parse action to convert to ints at parse time 
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+            date_str = integer + '/' + integer + '/' + integer 
+ 
+            # note that integer fields are now ints, not strings 
+            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31] 
+        """ 
+        self.parseAction = list(map(_trim_arity, list(fns))) 
+        self.callDuringTry = kwargs.get("callDuringTry", False) 
+        return self 
+ 
+    def addParseAction( self, *fns, **kwargs ): 
+        """ 
+        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}. 
+         
+        See examples in L{I{copy}<copy>}. 
+        """ 
+        self.parseAction += list(map(_trim_arity, list(fns))) 
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False) 
+        return self 
+ 
+    def addCondition(self, *fns, **kwargs): 
+        """Add a boolean predicate function to expression's list of parse actions. See  
+        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction},  
+        functions passed to C{addCondition} need to return boolean success/fail of the condition. 
+ 
+        Optional keyword arguments: 
+         - message = define a custom message to be used in the raised exception 
+         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException 
+          
+        Example:: 
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+            year_int = integer.copy() 
+            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later") 
+            date_str = year_int + '/' + integer + '/' + integer 
+ 
+            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1) 
+        """ 
+        msg = kwargs.get("message", "failed user-defined condition") 
+        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException 
+        for fn in fns: 
+            def pa(s,l,t): 
+                if not bool(_trim_arity(fn)(s,l,t)): 
+                    raise exc_type(s,l,msg) 
+            self.parseAction.append(pa) 
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False) 
+        return self 
+ 
+    def setFailAction( self, fn ): 
+        """Define action to perform if parsing fails at this expression. 
+           Fail acton fn is a callable function that takes the arguments 
+           C{fn(s,loc,expr,err)} where: 
+            - s = string being parsed 
+            - loc = location where expression match was attempted and failed 
+            - expr = the parse expression that failed 
+            - err = the exception thrown 
+           The function returns no value.  It may throw C{L{ParseFatalException}} 
+           if it is desired to stop parsing immediately.""" 
+        self.failAction = fn 
+        return self 
+ 
+    def _skipIgnorables( self, instring, loc ): 
+        exprsFound = True 
+        while exprsFound: 
+            exprsFound = False 
+            for e in self.ignoreExprs: 
+                try: 
+                    while 1: 
+                        loc,dummy = e._parse( instring, loc ) 
+                        exprsFound = True 
+                except ParseException: 
+                    pass 
+        return loc 
+ 
+    def preParse( self, instring, loc ): 
+        if self.ignoreExprs: 
+            loc = self._skipIgnorables( instring, loc ) 
+ 
+        if self.skipWhitespace: 
+            wt = self.whiteChars 
+            instrlen = len(instring) 
+            while loc < instrlen and instring[loc] in wt: 
+                loc += 1 
+ 
+        return loc 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        return loc, [] 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        return tokenlist 
+ 
+    #~ @profile 
+    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ): 
+        debugging = ( self.debug ) #and doActions ) 
+ 
+        if debugging or self.failAction: 
+            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )) 
+            if (self.debugActions[0] ): 
+                self.debugActions[0]( instring, loc, self ) 
+            if callPreParse and self.callPreparse: 
+                preloc = self.preParse( instring, loc ) 
+            else: 
+                preloc = loc 
+            tokensStart = preloc 
+            try: 
+                try: 
+                    loc,tokens = self.parseImpl( instring, preloc, doActions ) 
+                except IndexError: 
+                    raise ParseException( instring, len(instring), self.errmsg, self ) 
+            except ParseBaseException as err: 
+                #~ print ("Exception raised:", err) 
+                if self.debugActions[2]: 
+                    self.debugActions[2]( instring, tokensStart, self, err ) 
+                if self.failAction: 
+                    self.failAction( instring, tokensStart, self, err ) 
+                raise 
+        else: 
+            if callPreParse and self.callPreparse: 
+                preloc = self.preParse( instring, loc ) 
+            else: 
+                preloc = loc 
+            tokensStart = preloc 
+            if self.mayIndexError or preloc >= len(instring): 
+                try: 
+                    loc,tokens = self.parseImpl( instring, preloc, doActions ) 
+                except IndexError: 
+                    raise ParseException( instring, len(instring), self.errmsg, self ) 
+            else: 
+                loc,tokens = self.parseImpl( instring, preloc, doActions ) 
+ 
+        tokens = self.postParse( instring, loc, tokens ) 
+ 
+        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults ) 
+        if self.parseAction and (doActions or self.callDuringTry): 
+            if debugging: 
+                try: 
+                    for fn in self.parseAction: 
+                        tokens = fn( instring, tokensStart, retTokens ) 
+                        if tokens is not None: 
+                            retTokens = ParseResults( tokens, 
+                                                      self.resultsName, 
+                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)), 
+                                                      modal=self.modalResults ) 
+                except ParseBaseException as err: 
+                    #~ print "Exception raised in user parse action:", err 
+                    if (self.debugActions[2] ): 
+                        self.debugActions[2]( instring, tokensStart, self, err ) 
+                    raise 
+            else: 
+                for fn in self.parseAction: 
+                    tokens = fn( instring, tokensStart, retTokens ) 
+                    if tokens is not None: 
+                        retTokens = ParseResults( tokens, 
+                                                  self.resultsName, 
+                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)), 
+                                                  modal=self.modalResults ) 
+        if debugging: 
+            #~ print ("Matched",self,"->",retTokens.asList()) 
+            if (self.debugActions[1] ): 
+                self.debugActions[1]( instring, tokensStart, loc, self, retTokens ) 
+ 
+        return loc, retTokens 
+ 
+    def tryParse( self, instring, loc ): 
+        try: 
+            return self._parse( instring, loc, doActions=False )[0] 
+        except ParseFatalException: 
+            raise ParseException( instring, loc, self.errmsg, self) 
+     
+    def canParseNext(self, instring, loc): 
+        try: 
+            self.tryParse(instring, loc) 
+        except (ParseException, IndexError): 
+            return False 
+        else: 
+            return True 
+ 
+    class _UnboundedCache(object): 
+        def __init__(self): 
+            cache = {} 
+            self.not_in_cache = not_in_cache = object() 
+ 
+            def get(self, key): 
+                return cache.get(key, not_in_cache) 
+ 
+            def set(self, key, value): 
+                cache[key] = value 
+ 
+            def clear(self): 
+                cache.clear() 
+                 
+            def cache_len(self): 
+                return len(cache) 
+ 
+            self.get = types.MethodType(get, self) 
+            self.set = types.MethodType(set, self) 
+            self.clear = types.MethodType(clear, self) 
+            self.__len__ = types.MethodType(cache_len, self) 
+ 
+    if _OrderedDict is not None: 
+        class _FifoCache(object): 
+            def __init__(self, size): 
+                self.not_in_cache = not_in_cache = object() 
+ 
+                cache = _OrderedDict() 
+ 
+                def get(self, key): 
+                    return cache.get(key, not_in_cache) 
+ 
+                def set(self, key, value): 
+                    cache[key] = value 
+                    while len(cache) > size: 
+                        try: 
+                            cache.popitem(False) 
+                        except KeyError: 
+                            pass 
+ 
+                def clear(self): 
+                    cache.clear() 
+ 
+                def cache_len(self): 
+                    return len(cache) 
+ 
+                self.get = types.MethodType(get, self) 
+                self.set = types.MethodType(set, self) 
+                self.clear = types.MethodType(clear, self) 
+                self.__len__ = types.MethodType(cache_len, self) 
+ 
+    else: 
+        class _FifoCache(object): 
+            def __init__(self, size): 
+                self.not_in_cache = not_in_cache = object() 
+ 
+                cache = {} 
+                key_fifo = collections.deque([], size) 
+ 
+                def get(self, key): 
+                    return cache.get(key, not_in_cache) 
+ 
+                def set(self, key, value): 
+                    cache[key] = value 
+                    while len(key_fifo) > size: 
+                        cache.pop(key_fifo.popleft(), None) 
+                    key_fifo.append(key) 
+ 
+                def clear(self): 
+                    cache.clear() 
+                    key_fifo.clear() 
+ 
+                def cache_len(self): 
+                    return len(cache) 
+ 
+                self.get = types.MethodType(get, self) 
+                self.set = types.MethodType(set, self) 
+                self.clear = types.MethodType(clear, self) 
+                self.__len__ = types.MethodType(cache_len, self) 
+ 
+    # argument cache for optimizing repeated calls when backtracking through recursive expressions 
+    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail 
+    packrat_cache_lock = RLock() 
+    packrat_cache_stats = [0, 0] 
+ 
+    # this method gets repeatedly called during backtracking with the same arguments - 
+    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression 
+    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ): 
+        HIT, MISS = 0, 1 
+        lookup = (self, instring, loc, callPreParse, doActions) 
+        with ParserElement.packrat_cache_lock: 
+            cache = ParserElement.packrat_cache 
+            value = cache.get(lookup) 
+            if value is cache.not_in_cache: 
+                ParserElement.packrat_cache_stats[MISS] += 1 
+                try: 
+                    value = self._parseNoCache(instring, loc, doActions, callPreParse) 
+                except ParseBaseException as pe: 
+                    # cache a copy of the exception, without the traceback 
+                    cache.set(lookup, pe.__class__(*pe.args)) 
+                    raise 
+                else: 
+                    cache.set(lookup, (value[0], value[1].copy())) 
+                    return value 
+            else: 
+                ParserElement.packrat_cache_stats[HIT] += 1 
+                if isinstance(value, Exception): 
+                    raise value 
+                return (value[0], value[1].copy()) 
+ 
+    _parse = _parseNoCache 
+ 
+    @staticmethod 
+    def resetCache(): 
+        ParserElement.packrat_cache.clear() 
+        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats) 
+ 
+    _packratEnabled = False 
+    @staticmethod 
+    def enablePackrat(cache_size_limit=128): 
+        """Enables "packrat" parsing, which adds memoizing to the parsing logic. 
+           Repeated parse attempts at the same string location (which happens 
+           often in many complex grammars) can immediately return a cached value, 
+           instead of re-executing parsing/validating code.  Memoizing is done of 
+           both valid results and parsing exceptions. 
+            
+           Parameters: 
+            - cache_size_limit - (default=C{128}) - if an integer value is provided 
+              will limit the size of the packrat cache; if None is passed, then 
+              the cache size will be unbounded; if 0 is passed, the cache will 
+              be effectively disabled. 
+             
+           This speedup may break existing programs that use parse actions that 
+           have side-effects.  For this reason, packrat parsing is disabled when 
+           you first import pyparsing.  To activate the packrat feature, your 
+           program must call the class method C{ParserElement.enablePackrat()}.  If 
+           your program uses C{psyco} to "compile as you go", you must call 
+           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this, 
+           Python will crash.  For best results, call C{enablePackrat()} immediately 
+           after importing pyparsing. 
+            
+           Example:: 
+               import pyparsing 
+               pyparsing.ParserElement.enablePackrat() 
+        """ 
+        if not ParserElement._packratEnabled: 
+            ParserElement._packratEnabled = True 
+            if cache_size_limit is None: 
+                ParserElement.packrat_cache = ParserElement._UnboundedCache() 
+            else: 
+                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit) 
+            ParserElement._parse = ParserElement._parseCache 
+ 
+    def parseString( self, instring, parseAll=False ): 
+        """ 
+        Execute the parse expression with the given string. 
+        This is the main interface to the client code, once the complete 
+        expression has been built. 
+ 
+        If you want the grammar to require that the entire input string be 
+        successfully parsed, then set C{parseAll} to True (equivalent to ending 
+        the grammar with C{L{StringEnd()}}). 
+ 
+        Note: C{parseString} implicitly calls C{expandtabs()} on the input string, 
+        in order to report proper column numbers in parse actions. 
+        If the input string contains tabs and 
+        the grammar uses parse actions that use the C{loc} argument to index into the 
+        string being parsed, you can ensure you have a consistent view of the input 
+        string by: 
+         - calling C{parseWithTabs} on your grammar before calling C{parseString} 
+           (see L{I{parseWithTabs}<parseWithTabs>}) 
+         - define your parse action using the full C{(s,loc,toks)} signature, and 
+           reference the input string using the parse action's C{s} argument 
+         - explictly expand the tabs in your input string before calling 
+           C{parseString} 
+         
+        Example:: 
+            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa'] 
+            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text 
+        """ 
+        ParserElement.resetCache() 
+        if not self.streamlined: 
+            self.streamline() 
+            #~ self.saveAsList = True 
+        for e in self.ignoreExprs: 
+            e.streamline() 
+        if not self.keepTabs: 
+            instring = instring.expandtabs() 
+        try: 
+            loc, tokens = self._parse( instring, 0 ) 
+            if parseAll: 
+                loc = self.preParse( instring, loc ) 
+                se = Empty() + StringEnd() 
+                se._parse( instring, loc ) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+        else: 
+            return tokens 
+ 
+    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ): 
+        """ 
+        Scan the input string for expression matches.  Each match will return the 
+        matching tokens, start location, and end location.  May be called with optional 
+        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If 
+        C{overlap} is specified, then overlapping matches will be reported. 
+ 
+        Note that the start and end locations are reported relative to the string 
+        being parsed.  See L{I{parseString}<parseString>} for more information on parsing 
+        strings with embedded tabs. 
+ 
+        Example:: 
+            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987" 
+            print(source) 
+            for tokens,start,end in Word(alphas).scanString(source): 
+                print(' '*start + '^'*(end-start)) 
+                print(' '*start + tokens[0]) 
+         
+        prints:: 
+         
+            sldjf123lsdjjkf345sldkjf879lkjsfd987 
+            ^^^^^ 
+            sldjf 
+                    ^^^^^^^ 
+                    lsdjjkf 
+                              ^^^^^^ 
+                              sldkjf 
+                                       ^^^^^^ 
+                                       lkjsfd 
+        """ 
+        if not self.streamlined: 
+            self.streamline() 
+        for e in self.ignoreExprs: 
+            e.streamline() 
+ 
+        if not self.keepTabs: 
+            instring = _ustr(instring).expandtabs() 
+        instrlen = len(instring) 
+        loc = 0 
+        preparseFn = self.preParse 
+        parseFn = self._parse 
+        ParserElement.resetCache() 
+        matches = 0 
+        try: 
+            while loc <= instrlen and matches < maxMatches: 
+                try: 
+                    preloc = preparseFn( instring, loc ) 
+                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False ) 
+                except ParseException: 
+                    loc = preloc+1 
+                else: 
+                    if nextLoc > loc: 
+                        matches += 1 
+                        yield tokens, preloc, nextLoc 
+                        if overlap: 
+                            nextloc = preparseFn( instring, loc ) 
+                            if nextloc > loc: 
+                                loc = nextLoc 
+                            else: 
+                                loc += 1 
+                        else: 
+                            loc = nextLoc 
+                    else: 
+                        loc = preloc+1 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def transformString( self, instring ): 
+        """ 
+        Extension to C{L{scanString}}, to modify matching text with modified tokens that may 
+        be returned from a parse action.  To use C{transformString}, define a grammar and 
+        attach a parse action to it that modifies the returned token list. 
+        Invoking C{transformString()} on a target string will then scan for matches, 
+        and replace the matched text patterns according to the logic in the parse 
+        action.  C{transformString()} returns the resulting transformed string. 
+         
+        Example:: 
+            wd = Word(alphas) 
+            wd.setParseAction(lambda toks: toks[0].title()) 
+             
+            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york.")) 
+        Prints:: 
+            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York. 
+        """ 
+        out = [] 
+        lastE = 0 
+        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to 
+        # keep string locs straight between transformString and scanString 
+        self.keepTabs = True 
+        try: 
+            for t,s,e in self.scanString( instring ): 
+                out.append( instring[lastE:s] ) 
+                if t: 
+                    if isinstance(t,ParseResults): 
+                        out += t.asList() 
+                    elif isinstance(t,list): 
+                        out += t 
+                    else: 
+                        out.append(t) 
+                lastE = e 
+            out.append(instring[lastE:]) 
+            out = [o for o in out if o] 
+            return "".join(map(_ustr,_flatten(out))) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def searchString( self, instring, maxMatches=_MAX_INT ): 
+        """ 
+        Another extension to C{L{scanString}}, simplifying the access to the tokens found 
+        to match the given parse expression.  May be called with optional 
+        C{maxMatches} argument, to clip searching after 'n' matches are found. 
+         
+        Example:: 
+            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters 
+            cap_word = Word(alphas.upper(), alphas.lower()) 
+             
+            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")) 
+ 
+            # the sum() builtin can be used to merge results into a single ParseResults object 
+            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))) 
+        prints:: 
+            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']] 
+            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity'] 
+        """ 
+        try: 
+            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ]) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False): 
+        """ 
+        Generator method to split a string using the given expression as a separator. 
+        May be called with optional C{maxsplit} argument, to limit the number of splits; 
+        and the optional C{includeSeparators} argument (default=C{False}), if the separating 
+        matching text should be included in the split results. 
+         
+        Example::         
+            punc = oneOf(list(".,;:/-!?")) 
+            print(list(punc.split("This, this?, this sentence, is badly punctuated!"))) 
+        prints:: 
+            ['This', ' this', '', ' this sentence', ' is badly punctuated', ''] 
+        """ 
+        splits = 0 
+        last = 0 
+        for t,s,e in self.scanString(instring, maxMatches=maxsplit): 
+            yield instring[last:s] 
+            if includeSeparators: 
+                yield t[0] 
+            last = e 
+        yield instring[last:] 
+ 
+    def __add__(self, other ): 
+        """ 
+        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement 
+        converts them to L{Literal}s by default. 
+         
+        Example:: 
+            greet = Word(alphas) + "," + Word(alphas) + "!" 
+            hello = "Hello, World!" 
+            print (hello, "->", greet.parseString(hello)) 
+        Prints:: 
+            Hello, World! -> ['Hello', ',', 'World', '!'] 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return And( [ self, other ] ) 
+ 
+    def __radd__(self, other ): 
+        """ 
+        Implementation of + operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other + self 
+ 
+    def __sub__(self, other): 
+        """ 
+        Implementation of - operator, returns C{L{And}} with error stop 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return self + And._ErrorStop() + other 
+ 
+    def __rsub__(self, other ): 
+        """ 
+        Implementation of - operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other - self 
+ 
+    def __mul__(self,other): 
+        """ 
+        Implementation of * operator, allows use of C{expr * 3} in place of 
+        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer 
+        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples 
+        may also include C{None} as in: 
+         - C{expr*(n,None)} or C{expr*(n,)} is equivalent 
+              to C{expr*n + L{ZeroOrMore}(expr)} 
+              (read as "at least n instances of C{expr}") 
+         - C{expr*(None,n)} is equivalent to C{expr*(0,n)} 
+              (read as "0 to n instances of C{expr}") 
+         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)} 
+         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)} 
+ 
+        Note that C{expr*(None,n)} does not raise an exception if 
+        more than n exprs exist in the input stream; that is, 
+        C{expr*(None,n)} does not enforce a maximum number of expr 
+        occurrences.  If this behavior is desired, then write 
+        C{expr*(None,n) + ~expr} 
+        """ 
+        if isinstance(other,int): 
+            minElements, optElements = other,0 
+        elif isinstance(other,tuple): 
+            other = (other + (None, None))[:2] 
+            if other[0] is None: 
+                other = (0, other[1]) 
+            if isinstance(other[0],int) and other[1] is None: 
+                if other[0] == 0: 
+                    return ZeroOrMore(self) 
+                if other[0] == 1: 
+                    return OneOrMore(self) 
+                else: 
+                    return self*other[0] + ZeroOrMore(self) 
+            elif isinstance(other[0],int) and isinstance(other[1],int): 
+                minElements, optElements = other 
+                optElements -= minElements 
+            else: 
+                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1])) 
+        else: 
+            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other)) 
+ 
+        if minElements < 0: 
+            raise ValueError("cannot multiply ParserElement by negative value") 
+        if optElements < 0: 
+            raise ValueError("second tuple value must be greater or equal to first tuple value") 
+        if minElements == optElements == 0: 
+            raise ValueError("cannot multiply ParserElement by 0 or (0,0)") 
+ 
+        if (optElements): 
+            def makeOptionalList(n): 
+                if n>1: 
+                    return Optional(self + makeOptionalList(n-1)) 
+                else: 
+                    return Optional(self) 
+            if minElements: 
+                if minElements == 1: 
+                    ret = self + makeOptionalList(optElements) 
+                else: 
+                    ret = And([self]*minElements) + makeOptionalList(optElements) 
+            else: 
+                ret = makeOptionalList(optElements) 
+        else: 
+            if minElements == 1: 
+                ret = self 
+            else: 
+                ret = And([self]*minElements) 
+        return ret 
+ 
+    def __rmul__(self, other): 
+        return self.__mul__(other) 
+ 
+    def __or__(self, other ): 
+        """ 
+        Implementation of | operator - returns C{L{MatchFirst}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return MatchFirst( [ self, other ] ) 
+ 
+    def __ror__(self, other ): 
+        """ 
+        Implementation of | operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other | self 
+ 
+    def __xor__(self, other ): 
+        """ 
+        Implementation of ^ operator - returns C{L{Or}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return Or( [ self, other ] ) 
+ 
+    def __rxor__(self, other ): 
+        """ 
+        Implementation of ^ operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other ^ self 
+ 
+    def __and__(self, other ): 
+        """ 
+        Implementation of & operator - returns C{L{Each}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return Each( [ self, other ] ) 
+ 
+    def __rand__(self, other ): 
+        """ 
+        Implementation of & operator when left operand is not a C{L{ParserElement}} 
+        """ 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        if not isinstance( other, ParserElement ): 
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other), 
+                    SyntaxWarning, stacklevel=2) 
+            return None 
+        return other & self 
+ 
+    def __invert__( self ): 
+        """ 
+        Implementation of ~ operator - returns C{L{NotAny}} 
+        """ 
+        return NotAny( self ) 
+ 
+    def __call__(self, name=None): 
+        """ 
+        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}. 
+         
+        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be 
+        passed as C{True}. 
+            
+        If C{name} is omitted, same as calling C{L{copy}}. 
+ 
+        Example:: 
+            # these are equivalent 
+            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno") 
+            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")              
+        """ 
+        if name is not None: 
+            return self.setResultsName(name) 
+        else: 
+            return self.copy() 
+ 
+    def suppress( self ): 
+        """ 
+        Suppresses the output of this C{ParserElement}; useful to keep punctuation from 
+        cluttering up returned output. 
+        """ 
+        return Suppress( self ) 
+ 
+    def leaveWhitespace( self ): 
+        """ 
+        Disables the skipping of whitespace before matching the characters in the 
+        C{ParserElement}'s defined pattern.  This is normally only used internally by 
+        the pyparsing module, but may be needed in some whitespace-sensitive grammars. 
+        """ 
+        self.skipWhitespace = False 
+        return self 
+ 
+    def setWhitespaceChars( self, chars ): 
+        """ 
+        Overrides the default whitespace chars 
+        """ 
+        self.skipWhitespace = True 
+        self.whiteChars = chars 
+        self.copyDefaultWhiteChars = False 
+        return self 
+ 
+    def parseWithTabs( self ): 
+        """ 
+        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string. 
+        Must be called before C{parseString} when the input grammar contains elements that 
+        match C{<TAB>} characters. 
+        """ 
+        self.keepTabs = True 
+        return self 
+ 
+    def ignore( self, other ): 
+        """ 
+        Define expression to be ignored (e.g., comments) while doing pattern 
+        matching; may be called repeatedly, to define multiple comment or other 
+        ignorable patterns. 
+         
+        Example:: 
+            patt = OneOrMore(Word(alphas)) 
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj'] 
+             
+            patt.ignore(cStyleComment) 
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd'] 
+        """ 
+        if isinstance(other, basestring): 
+            other = Suppress(other) 
+ 
+        if isinstance( other, Suppress ): 
+            if other not in self.ignoreExprs: 
+                self.ignoreExprs.append(other) 
+        else: 
+            self.ignoreExprs.append( Suppress( other.copy() ) ) 
+        return self 
+ 
+    def setDebugActions( self, startAction, successAction, exceptionAction ): 
+        """ 
+        Enable display of debugging messages while doing pattern matching. 
+        """ 
+        self.debugActions = (startAction or _defaultStartDebugAction, 
+                             successAction or _defaultSuccessDebugAction, 
+                             exceptionAction or _defaultExceptionDebugAction) 
+        self.debug = True 
+        return self 
+ 
+    def setDebug( self, flag=True ): 
+        """ 
+        Enable display of debugging messages while doing pattern matching. 
+        Set C{flag} to True to enable, False to disable. 
+ 
+        Example:: 
+            wd = Word(alphas).setName("alphaword") 
+            integer = Word(nums).setName("numword") 
+            term = wd | integer 
+             
+            # turn on debugging for wd 
+            wd.setDebug() 
+ 
+            OneOrMore(term).parseString("abc 123 xyz 890") 
+         
+        prints:: 
+            Match alphaword at loc 0(1,1) 
+            Matched alphaword -> ['abc'] 
+            Match alphaword at loc 3(1,4) 
+            Exception raised:Expected alphaword (at char 4), (line:1, col:5) 
+            Match alphaword at loc 7(1,8) 
+            Matched alphaword -> ['xyz'] 
+            Match alphaword at loc 11(1,12) 
+            Exception raised:Expected alphaword (at char 12), (line:1, col:13) 
+            Match alphaword at loc 15(1,16) 
+            Exception raised:Expected alphaword (at char 15), (line:1, col:16) 
+ 
+        The output shown is that produced by the default debug actions - custom debug actions can be 
+        specified using L{setDebugActions}. Prior to attempting 
+        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"} 
+        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"} 
+        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression, 
+        which makes debugging and exception messages easier to understand - for instance, the default 
+        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}. 
+        """ 
+        if flag: 
+            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction ) 
+        else: 
+            self.debug = False 
+        return self 
+ 
+    def __str__( self ): 
+        return self.name 
+ 
+    def __repr__( self ): 
+        return _ustr(self) 
+ 
+    def streamline( self ): 
+        self.streamlined = True 
+        self.strRepr = None 
+        return self 
+ 
+    def checkRecursion( self, parseElementList ): 
+        pass 
+ 
+    def validate( self, validateTrace=[] ): 
+        """ 
+        Check defined expressions for valid structure, check for infinite recursive definitions. 
+        """ 
+        self.checkRecursion( [] ) 
+ 
+    def parseFile( self, file_or_filename, parseAll=False ): 
+        """ 
+        Execute the parse expression on the given file or filename. 
+        If a filename is specified (instead of a file object), 
+        the entire file is opened, read, and closed before parsing. 
+        """ 
+        try: 
+            file_contents = file_or_filename.read() 
+        except AttributeError: 
+            with open(file_or_filename, "r") as f: 
+                file_contents = f.read() 
+        try: 
+            return self.parseString(file_contents, parseAll) 
+        except ParseBaseException as exc: 
+            if ParserElement.verbose_stacktrace: 
+                raise 
+            else: 
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace 
+                raise exc 
+ 
+    def __eq__(self,other): 
+        if isinstance(other, ParserElement): 
+            return self is other or vars(self) == vars(other) 
+        elif isinstance(other, basestring): 
+            return self.matches(other) 
+        else: 
+            return super(ParserElement,self)==other 
+ 
+    def __ne__(self,other): 
+        return not (self == other) 
+ 
+    def __hash__(self): 
+        return hash(id(self)) 
+ 
+    def __req__(self,other): 
+        return self == other 
+ 
+    def __rne__(self,other): 
+        return not (self == other) 
+ 
+    def matches(self, testString, parseAll=True): 
+        """ 
+        Method for quick testing of a parser against a test string. Good for simple  
+        inline microtests of sub expressions while building up larger parser. 
+            
+        Parameters: 
+         - testString - to test against this expression for a match 
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests 
+             
+        Example:: 
+            expr = Word(nums) 
+            assert expr.matches("100") 
+        """ 
+        try: 
+            self.parseString(_ustr(testString), parseAll=parseAll) 
+            return True 
+        except ParseBaseException: 
+            return False 
+                 
+    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False): 
+        """ 
+        Execute the parse expression on a series of test strings, showing each 
+        test, the parsed results or where the parse failed. Quick and easy way to 
+        run a parse expression against a list of sample strings. 
+            
+        Parameters: 
+         - tests - a list of separate test strings, or a multiline string of test strings 
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests            
+         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test  
+              string; pass None to disable comment filtering 
+         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline; 
+              if False, only dump nested list 
+         - printResults - (default=C{True}) prints test output to stdout 
+         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing 
+ 
+        Returns: a (success, results) tuple, where success indicates that all tests succeeded 
+        (or failed if C{failureTests} is True), and the results contain a list of lines of each  
+        test's output 
+         
+        Example:: 
+            number_expr = pyparsing_common.number.copy() 
+ 
+            result = number_expr.runTests(''' 
+                # unsigned integer 
+                100 
+                # negative integer 
+                -100 
+                # float with scientific notation 
+                6.02e23 
+                # integer with scientific notation 
+                1e-12 
+                ''') 
+            print("Success" if result[0] else "Failed!") 
+ 
+            result = number_expr.runTests(''' 
+                # stray character 
+                100Z 
+                # missing leading digit before '.' 
+                -.100 
+                # too many '.' 
+                3.14.159 
+                ''', failureTests=True) 
+            print("Success" if result[0] else "Failed!") 
+        prints:: 
+            # unsigned integer 
+            100 
+            [100] 
+ 
+            # negative integer 
+            -100 
+            [-100] 
+ 
+            # float with scientific notation 
+            6.02e23 
+            [6.02e+23] 
+ 
+            # integer with scientific notation 
+            1e-12 
+            [1e-12] 
+ 
+            Success 
+             
+            # stray character 
+            100Z 
+               ^ 
+            FAIL: Expected end of text (at char 3), (line:1, col:4) 
+ 
+            # missing leading digit before '.' 
+            -.100 
+            ^ 
+            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1) 
+ 
+            # too many '.' 
+            3.14.159 
+                ^ 
+            FAIL: Expected end of text (at char 4), (line:1, col:5) 
+ 
+            Success 
+ 
+        Each test string must be on a single line. If you want to test a string that spans multiple 
+        lines, create a test like this:: 
+ 
+            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines") 
+         
+        (Note that this is a raw string literal, you must include the leading 'r'.) 
+        """ 
+        if isinstance(tests, basestring): 
+            tests = list(map(str.strip, tests.rstrip().splitlines())) 
+        if isinstance(comment, basestring): 
+            comment = Literal(comment) 
+        allResults = [] 
+        comments = [] 
+        success = True 
+        for t in tests: 
+            if comment is not None and comment.matches(t, False) or comments and not t: 
+                comments.append(t) 
+                continue 
+            if not t: 
+                continue 
+            out = ['\n'.join(comments), t] 
+            comments = [] 
+            try: 
+                t = t.replace(r'\n','\n') 
+                result = self.parseString(t, parseAll=parseAll) 
+                out.append(result.dump(full=fullDump)) 
+                success = success and not failureTests 
+            except ParseBaseException as pe: 
+                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else "" 
+                if '\n' in t: 
+                    out.append(line(pe.loc, t)) 
+                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal) 
+                else: 
+                    out.append(' '*pe.loc + '^' + fatal) 
+                out.append("FAIL: " + str(pe)) 
+                success = success and failureTests 
+                result = pe 
+            except Exception as exc: 
+                out.append("FAIL-EXCEPTION: " + str(exc)) 
+                success = success and failureTests 
+                result = exc 
+ 
+            if printResults: 
+                if fullDump: 
+                    out.append('') 
+                print('\n'.join(out)) 
+ 
+            allResults.append((t, result)) 
+         
+        return success, allResults 
+ 
+         
+class Token(ParserElement): 
+    """ 
+    Abstract C{ParserElement} subclass, for defining atomic matching patterns. 
+    """ 
+    def __init__( self ): 
+        super(Token,self).__init__( savelist=False ) 
+ 
+ 
+class Empty(Token): 
+    """ 
+    An empty token, will always match. 
+    """ 
+    def __init__( self ): 
+        super(Empty,self).__init__() 
+        self.name = "Empty" 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+ 
+ 
+class NoMatch(Token): 
+    """ 
+    A token that will never match. 
+    """ 
+    def __init__( self ): 
+        super(NoMatch,self).__init__() 
+        self.name = "NoMatch" 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+        self.errmsg = "Unmatchable token" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+ 
+class Literal(Token): 
+    """ 
+    Token to exactly match a specified string. 
+     
+    Example:: 
+        Literal('blah').parseString('blah')  # -> ['blah'] 
+        Literal('blah').parseString('blahfooblah')  # -> ['blah'] 
+        Literal('blah').parseString('bla')  # -> Exception: Expected "blah" 
+     
+    For case-insensitive matching, use L{CaselessLiteral}. 
+     
+    For keyword matching (force word break before and after the matched string), 
+    use L{Keyword} or L{CaselessKeyword}. 
+    """ 
+    def __init__( self, matchString ): 
+        super(Literal,self).__init__() 
+        self.match = matchString 
+        self.matchLen = len(matchString) 
+        try: 
+            self.firstMatchChar = matchString[0] 
+        except IndexError: 
+            warnings.warn("null string passed to Literal; use Empty() instead", 
+                            SyntaxWarning, stacklevel=2) 
+            self.__class__ = Empty 
+        self.name = '"%s"' % _ustr(self.match) 
+        self.errmsg = "Expected " + self.name 
+        self.mayReturnEmpty = False 
+        self.mayIndexError = False 
+ 
+    # Performance tuning: this routine gets called a *lot* 
+    # if this is a single character match string  and the first character matches, 
+    # short-circuit as quickly as possible, and avoid calling startswith 
+    #~ @profile 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if (instring[loc] == self.firstMatchChar and 
+            (self.matchLen==1 or instring.startswith(self.match,loc)) ): 
+            return loc+self.matchLen, self.match 
+        raise ParseException(instring, loc, self.errmsg, self) 
+_L = Literal 
+ParserElement._literalStringClass = Literal 
+ 
+class Keyword(Token): 
+    """ 
+    Token to exactly match a specified string as a keyword, that is, it must be 
+    immediately followed by a non-keyword character.  Compare with C{L{Literal}}: 
+     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}. 
+     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'} 
+    Accepts two optional constructor arguments in addition to the keyword string: 
+     - C{identChars} is a string of characters that would be valid identifier characters, 
+          defaulting to all alphanumerics + "_" and "$" 
+     - C{caseless} allows case-insensitive matching, default is C{False}. 
+        
+    Example:: 
+        Keyword("start").parseString("start")  # -> ['start'] 
+        Keyword("start").parseString("starting")  # -> Exception 
+ 
+    For case-insensitive matching, use L{CaselessKeyword}. 
+    """ 
+    DEFAULT_KEYWORD_CHARS = alphanums+"_$" 
+ 
+    def __init__( self, matchString, identChars=None, caseless=False ): 
+        super(Keyword,self).__init__() 
+        if identChars is None: 
+            identChars = Keyword.DEFAULT_KEYWORD_CHARS 
+        self.match = matchString 
+        self.matchLen = len(matchString) 
+        try: 
+            self.firstMatchChar = matchString[0] 
+        except IndexError: 
+            warnings.warn("null string passed to Keyword; use Empty() instead", 
+                            SyntaxWarning, stacklevel=2) 
+        self.name = '"%s"' % self.match 
+        self.errmsg = "Expected " + self.name 
+        self.mayReturnEmpty = False 
+        self.mayIndexError = False 
+        self.caseless = caseless 
+        if caseless: 
+            self.caselessmatch = matchString.upper() 
+            identChars = identChars.upper() 
+        self.identChars = set(identChars) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.caseless: 
+            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and 
+                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and 
+                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ): 
+                return loc+self.matchLen, self.match 
+        else: 
+            if (instring[loc] == self.firstMatchChar and 
+                (self.matchLen==1 or instring.startswith(self.match,loc)) and 
+                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and 
+                (loc == 0 or instring[loc-1] not in self.identChars) ): 
+                return loc+self.matchLen, self.match 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+    def copy(self): 
+        c = super(Keyword,self).copy() 
+        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS 
+        return c 
+ 
+    @staticmethod 
+    def setDefaultKeywordChars( chars ): 
+        """Overrides the default Keyword chars 
+        """ 
+        Keyword.DEFAULT_KEYWORD_CHARS = chars 
+ 
+class CaselessLiteral(Literal): 
+    """ 
+    Token to match a specified string, ignoring case of letters. 
+    Note: the matched results will always be in the case of the given 
+    match string, NOT the case of the input text. 
+ 
+    Example:: 
+        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD'] 
+         
+    (Contrast with example for L{CaselessKeyword}.) 
+    """ 
+    def __init__( self, matchString ): 
+        super(CaselessLiteral,self).__init__( matchString.upper() ) 
+        # Preserve the defining literal. 
+        self.returnString = matchString 
+        self.name = "'%s'" % self.returnString 
+        self.errmsg = "Expected " + self.name 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if instring[ loc:loc+self.matchLen ].upper() == self.match: 
+            return loc+self.matchLen, self.returnString 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class CaselessKeyword(Keyword): 
+    """ 
+    Caseless version of L{Keyword}. 
+ 
+    Example:: 
+        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD'] 
+         
+    (Contrast with example for L{CaselessLiteral}.) 
+    """ 
+    def __init__( self, matchString, identChars=None ): 
+        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True ) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and 
+             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ): 
+            return loc+self.matchLen, self.match 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class CloseMatch(Token): 
+    """ 
+    A variation on L{Literal} which matches "close" matches, that is,  
+    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters: 
+     - C{match_string} - string to be matched 
+     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match 
+     
+    The results from a successful parse will contain the matched text from the input string and the following named results: 
+     - C{mismatches} - a list of the positions within the match_string where mismatches were found 
+     - C{original} - the original match_string used to compare against the input string 
+     
+    If C{mismatches} is an empty list, then the match was an exact match. 
+     
+    Example:: 
+        patt = CloseMatch("ATCATCGAATGGA") 
+        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']}) 
+        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1) 
+ 
+        # exact match 
+        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']}) 
+ 
+        # close match allowing up to 2 mismatches 
+        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2) 
+        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']}) 
+    """ 
+    def __init__(self, match_string, maxMismatches=1): 
+        super(CloseMatch,self).__init__() 
+        self.name = match_string 
+        self.match_string = match_string 
+        self.maxMismatches = maxMismatches 
+        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches) 
+        self.mayIndexError = False 
+        self.mayReturnEmpty = False 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        start = loc 
+        instrlen = len(instring) 
+        maxloc = start + len(self.match_string) 
+ 
+        if maxloc <= instrlen: 
+            match_string = self.match_string 
+            match_stringloc = 0 
+            mismatches = [] 
+            maxMismatches = self.maxMismatches 
+ 
+            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)): 
+                src,mat = s_m 
+                if src != mat: 
+                    mismatches.append(match_stringloc) 
+                    if len(mismatches) > maxMismatches: 
+                        break 
+            else: 
+                loc = match_stringloc + 1 
+                results = ParseResults([instring[start:loc]]) 
+                results['original'] = self.match_string 
+                results['mismatches'] = mismatches 
+                return loc, results 
+ 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+ 
+class Word(Token): 
+    """ 
+    Token for matching words composed of allowed character sets. 
+    Defined with string containing all allowed initial characters, 
+    an optional string containing allowed body characters (if omitted, 
+    defaults to the initial character set), and an optional minimum, 
+    maximum, and/or exact length.  The default value for C{min} is 1 (a 
+    minimum value < 1 is not valid); the default values for C{max} and C{exact} 
+    are 0, meaning no maximum or exact length restriction. An optional 
+    C{excludeChars} parameter can list characters that might be found in  
+    the input C{bodyChars} string; useful to define a word of all printables 
+    except for one or two characters, for instance. 
+     
+    L{srange} is useful for defining custom character set strings for defining  
+    C{Word} expressions, using range notation from regular expression character sets. 
+     
+    A common mistake is to use C{Word} to match a specific literal string, as in  
+    C{Word("Address")}. Remember that C{Word} uses the string argument to define 
+    I{sets} of matchable characters. This expression would match "Add", "AAA", 
+    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'. 
+    To match an exact literal string, use L{Literal} or L{Keyword}. 
+ 
+    pyparsing includes helper strings for building Words: 
+     - L{alphas} 
+     - L{nums} 
+     - L{alphanums} 
+     - L{hexnums} 
+     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.) 
+     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.) 
+     - L{printables} (any non-whitespace character) 
+ 
+    Example:: 
+        # a word composed of digits 
+        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9")) 
+         
+        # a word with a leading capital, and zero or more lowercase 
+        capital_word = Word(alphas.upper(), alphas.lower()) 
+ 
+        # hostnames are alphanumeric, with leading alpha, and '-' 
+        hostname = Word(alphas, alphanums+'-') 
+         
+        # roman numeral (not a strict parser, accepts invalid mix of characters) 
+        roman = Word("IVXLCDM") 
+         
+        # any string of non-whitespace characters, except for ',' 
+        csv_value = Word(printables, excludeChars=",") 
+    """ 
+    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ): 
+        super(Word,self).__init__() 
+        if excludeChars: 
+            initChars = ''.join(c for c in initChars if c not in excludeChars) 
+            if bodyChars: 
+                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars) 
+        self.initCharsOrig = initChars 
+        self.initChars = set(initChars) 
+        if bodyChars : 
+            self.bodyCharsOrig = bodyChars 
+            self.bodyChars = set(bodyChars) 
+        else: 
+            self.bodyCharsOrig = initChars 
+            self.bodyChars = set(initChars) 
+ 
+        self.maxSpecified = max > 0 
+ 
+        if min < 1: 
+            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted") 
+ 
+        self.minLen = min 
+ 
+        if max > 0: 
+            self.maxLen = max 
+        else: 
+            self.maxLen = _MAX_INT 
+ 
+        if exact > 0: 
+            self.maxLen = exact 
+            self.minLen = exact 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayIndexError = False 
+        self.asKeyword = asKeyword 
+ 
+        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0): 
+            if self.bodyCharsOrig == self.initCharsOrig: 
+                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig) 
+            elif len(self.initCharsOrig) == 1: 
+                self.reString = "%s[%s]*" % \ 
+                                      (re.escape(self.initCharsOrig), 
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),) 
+            else: 
+                self.reString = "[%s][%s]*" % \ 
+                                      (_escapeRegexRangeChars(self.initCharsOrig), 
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),) 
+            if self.asKeyword: 
+                self.reString = r"\b"+self.reString+r"\b" 
+            try: 
+                self.re = re.compile( self.reString ) 
+            except Exception: 
+                self.re = None 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.re: 
+            result = self.re.match(instring,loc) 
+            if not result: 
+                raise ParseException(instring, loc, self.errmsg, self) 
+ 
+            loc = result.end() 
+            return loc, result.group() 
+ 
+        if not(instring[ loc ] in self.initChars): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        start = loc 
+        loc += 1 
+        instrlen = len(instring) 
+        bodychars = self.bodyChars 
+        maxloc = start + self.maxLen 
+        maxloc = min( maxloc, instrlen ) 
+        while loc < maxloc and instring[loc] in bodychars: 
+            loc += 1 
+ 
+        throwException = False 
+        if loc - start < self.minLen: 
+            throwException = True 
+        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars: 
+            throwException = True 
+        if self.asKeyword: 
+            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars): 
+                throwException = True 
+ 
+        if throwException: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        return loc, instring[start:loc] 
+ 
+    def __str__( self ): 
+        try: 
+            return super(Word,self).__str__() 
+        except Exception: 
+            pass 
+ 
+ 
+        if self.strRepr is None: 
+ 
+            def charsAsStr(s): 
+                if len(s)>4: 
+                    return s[:4]+"..." 
+                else: 
+                    return s 
+ 
+            if ( self.initCharsOrig != self.bodyCharsOrig ): 
+                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) ) 
+            else: 
+                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig) 
+ 
+        return self.strRepr 
+ 
+ 
+class Regex(Token): 
+    r""" 
+    Token for matching strings that match a given regular expression. 
+    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module. 
+    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as  
+    named parse results. 
+ 
+    Example:: 
+        realnum = Regex(r"[+-]?\d+\.\d*") 
+        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)') 
+        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression 
+        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})") 
+    """ 
+    compiledREtype = type(re.compile("[A-Z]")) 
+    def __init__( self, pattern, flags=0): 
+        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags.""" 
+        super(Regex,self).__init__() 
+ 
+        if isinstance(pattern, basestring): 
+            if not pattern: 
+                warnings.warn("null string passed to Regex; use Empty() instead", 
+                        SyntaxWarning, stacklevel=2) 
+ 
+            self.pattern = pattern 
+            self.flags = flags 
+ 
+            try: 
+                self.re = re.compile(self.pattern, self.flags) 
+                self.reString = self.pattern 
+            except sre_constants.error: 
+                warnings.warn("invalid pattern (%s) passed to Regex" % pattern, 
+                    SyntaxWarning, stacklevel=2) 
+                raise 
+ 
+        elif isinstance(pattern, Regex.compiledREtype): 
+            self.re = pattern 
+            self.pattern = \ 
+            self.reString = str(pattern) 
+            self.flags = flags 
+             
+        else: 
+            raise ValueError("Regex may only be constructed with a string or a compiled RE object") 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayIndexError = False 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        result = self.re.match(instring,loc) 
+        if not result: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        loc = result.end() 
+        d = result.groupdict() 
+        ret = ParseResults(result.group()) 
+        if d: 
+            for k in d: 
+                ret[k] = d[k] 
+        return loc,ret 
+ 
+    def __str__( self ): 
+        try: 
+            return super(Regex,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "Re:(%s)" % repr(self.pattern) 
+ 
+        return self.strRepr 
+ 
+ 
+class QuotedString(Token): 
+    r""" 
+    Token for matching strings that are delimited by quoting characters. 
+     
+    Defined with the following parameters: 
+        - quoteChar - string of one or more characters defining the quote delimiting string 
+        - escChar - character to escape quotes, typically backslash (default=C{None}) 
+        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None}) 
+        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False}) 
+        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True}) 
+        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar) 
+        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True}) 
+ 
+    Example:: 
+        qs = QuotedString('"') 
+        print(qs.searchString('lsjdf "This is the quote" sldjf')) 
+        complex_qs = QuotedString('{{', endQuoteChar='}}') 
+        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf')) 
+        sql_qs = QuotedString('"', escQuote='""') 
+        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf')) 
+    prints:: 
+        [['This is the quote']] 
+        [['This is the "quote"']] 
+        [['This is the quote with "embedded" quotes']] 
+    """ 
+    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True): 
+        super(QuotedString,self).__init__() 
+ 
+        # remove white space from quote chars - wont work anyway 
+        quoteChar = quoteChar.strip() 
+        if not quoteChar: 
+            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2) 
+            raise SyntaxError() 
+ 
+        if endQuoteChar is None: 
+            endQuoteChar = quoteChar 
+        else: 
+            endQuoteChar = endQuoteChar.strip() 
+            if not endQuoteChar: 
+                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2) 
+                raise SyntaxError() 
+ 
+        self.quoteChar = quoteChar 
+        self.quoteCharLen = len(quoteChar) 
+        self.firstQuoteChar = quoteChar[0] 
+        self.endQuoteChar = endQuoteChar 
+        self.endQuoteCharLen = len(endQuoteChar) 
+        self.escChar = escChar 
+        self.escQuote = escQuote 
+        self.unquoteResults = unquoteResults 
+        self.convertWhitespaceEscapes = convertWhitespaceEscapes 
+ 
+        if multiline: 
+            self.flags = re.MULTILINE | re.DOTALL 
+            self.pattern = r'%s(?:[^%s%s]' % \ 
+                ( re.escape(self.quoteChar), 
+                  _escapeRegexRangeChars(self.endQuoteChar[0]), 
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') ) 
+        else: 
+            self.flags = 0 
+            self.pattern = r'%s(?:[^%s\n\r%s]' % \ 
+                ( re.escape(self.quoteChar), 
+                  _escapeRegexRangeChars(self.endQuoteChar[0]), 
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') ) 
+        if len(self.endQuoteChar) > 1: 
+            self.pattern += ( 
+                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]), 
+                                               _escapeRegexRangeChars(self.endQuoteChar[i])) 
+                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')' 
+                ) 
+        if escQuote: 
+            self.pattern += (r'|(?:%s)' % re.escape(escQuote)) 
+        if escChar: 
+            self.pattern += (r'|(?:%s.)' % re.escape(escChar)) 
+            self.escCharReplacePattern = re.escape(self.escChar)+"(.)" 
+        self.pattern += (r')*%s' % re.escape(self.endQuoteChar)) 
+ 
+        try: 
+            self.re = re.compile(self.pattern, self.flags) 
+            self.reString = self.pattern 
+        except sre_constants.error: 
+            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern, 
+                SyntaxWarning, stacklevel=2) 
+            raise 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayIndexError = False 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None 
+        if not result: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        loc = result.end() 
+        ret = result.group() 
+ 
+        if self.unquoteResults: 
+ 
+            # strip off quotes 
+            ret = ret[self.quoteCharLen:-self.endQuoteCharLen] 
+ 
+            if isinstance(ret,basestring): 
+                # replace escaped whitespace 
+                if '\\' in ret and self.convertWhitespaceEscapes: 
+                    ws_map = { 
+                        r'\t' : '\t', 
+                        r'\n' : '\n', 
+                        r'\f' : '\f', 
+                        r'\r' : '\r', 
+                    } 
+                    for wslit,wschar in ws_map.items(): 
+                        ret = ret.replace(wslit, wschar) 
+ 
+                # replace escaped characters 
+                if self.escChar: 
+                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret) 
+ 
+                # replace escaped quotes 
+                if self.escQuote: 
+                    ret = ret.replace(self.escQuote, self.endQuoteChar) 
+ 
+        return loc, ret 
+ 
+    def __str__( self ): 
+        try: 
+            return super(QuotedString,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar) 
+ 
+        return self.strRepr 
+ 
+ 
+class CharsNotIn(Token): 
+    """ 
+    Token for matching words composed of characters I{not} in a given set (will 
+    include whitespace in matched characters if not listed in the provided exclusion set - see example). 
+    Defined with string containing all disallowed characters, and an optional 
+    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a 
+    minimum value < 1 is not valid); the default values for C{max} and C{exact} 
+    are 0, meaning no maximum or exact length restriction. 
+ 
+    Example:: 
+        # define a comma-separated-value as anything that is not a ',' 
+        csv_value = CharsNotIn(',') 
+        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213")) 
+    prints:: 
+        ['dkls', 'lsdkjf', 's12 34', '@!#', '213'] 
+    """ 
+    def __init__( self, notChars, min=1, max=0, exact=0 ): 
+        super(CharsNotIn,self).__init__() 
+        self.skipWhitespace = False 
+        self.notChars = notChars 
+ 
+        if min < 1: 
+            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted") 
+ 
+        self.minLen = min 
+ 
+        if max > 0: 
+            self.maxLen = max 
+        else: 
+            self.maxLen = _MAX_INT 
+ 
+        if exact > 0: 
+            self.maxLen = exact 
+            self.minLen = exact 
+ 
+        self.name = _ustr(self) 
+        self.errmsg = "Expected " + self.name 
+        self.mayReturnEmpty = ( self.minLen == 0 ) 
+        self.mayIndexError = False 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if instring[loc] in self.notChars: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        start = loc 
+        loc += 1 
+        notchars = self.notChars 
+        maxlen = min( start+self.maxLen, len(instring) ) 
+        while loc < maxlen and \ 
+              (instring[loc] not in notchars): 
+            loc += 1 
+ 
+        if loc - start < self.minLen: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        return loc, instring[start:loc] 
+ 
+    def __str__( self ): 
+        try: 
+            return super(CharsNotIn, self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            if len(self.notChars) > 4: 
+                self.strRepr = "!W:(%s...)" % self.notChars[:4] 
+            else: 
+                self.strRepr = "!W:(%s)" % self.notChars 
+ 
+        return self.strRepr 
+ 
+class White(Token): 
+    """ 
+    Special matching class for matching whitespace.  Normally, whitespace is ignored 
+    by pyparsing grammars.  This class is included when some whitespace structures 
+    are significant.  Define with a string containing the whitespace characters to be 
+    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments, 
+    as defined for the C{L{Word}} class. 
+    """ 
+    whiteStrs = { 
+        " " : "<SPC>", 
+        "\t": "<TAB>", 
+        "\n": "<LF>", 
+        "\r": "<CR>", 
+        "\f": "<FF>", 
+        } 
+    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0): 
+        super(White,self).__init__() 
+        self.matchWhite = ws 
+        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) ) 
+        #~ self.leaveWhitespace() 
+        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite)) 
+        self.mayReturnEmpty = True 
+        self.errmsg = "Expected " + self.name 
+ 
+        self.minLen = min 
+ 
+        if max > 0: 
+            self.maxLen = max 
+        else: 
+            self.maxLen = _MAX_INT 
+ 
+        if exact > 0: 
+            self.maxLen = exact 
+            self.minLen = exact 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if not(instring[ loc ] in self.matchWhite): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+        start = loc 
+        loc += 1 
+        maxloc = start + self.maxLen 
+        maxloc = min( maxloc, len(instring) ) 
+        while loc < maxloc and instring[loc] in self.matchWhite: 
+            loc += 1 
+ 
+        if loc - start < self.minLen: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        return loc, instring[start:loc] 
+ 
+ 
+class _PositionToken(Token): 
+    def __init__( self ): 
+        super(_PositionToken,self).__init__() 
+        self.name=self.__class__.__name__ 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+ 
+class GoToColumn(_PositionToken): 
+    """ 
+    Token to advance to a specific column of input text; useful for tabular report scraping. 
+    """ 
+    def __init__( self, colno ): 
+        super(GoToColumn,self).__init__() 
+        self.col = colno 
+ 
+    def preParse( self, instring, loc ): 
+        if col(loc,instring) != self.col: 
+            instrlen = len(instring) 
+            if self.ignoreExprs: 
+                loc = self._skipIgnorables( instring, loc ) 
+            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col : 
+                loc += 1 
+        return loc 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        thiscol = col( loc, instring ) 
+        if thiscol > self.col: 
+            raise ParseException( instring, loc, "Text not in expected column", self ) 
+        newloc = loc + self.col - thiscol 
+        ret = instring[ loc: newloc ] 
+        return newloc, ret 
+ 
+ 
+class LineStart(_PositionToken): 
+    """ 
+    Matches if current position is at the beginning of a line within the parse string 
+     
+    Example:: 
+     
+        test = '''\ 
+        AAA this line 
+        AAA and this line 
+          AAA but not this one 
+        B AAA and definitely not this one 
+        ''' 
+ 
+        for t in (LineStart() + 'AAA' + restOfLine).searchString(test): 
+            print(t) 
+     
+    Prints:: 
+        ['AAA', ' this line'] 
+        ['AAA', ' and this line']     
+ 
+    """ 
+    def __init__( self ): 
+        super(LineStart,self).__init__() 
+        self.errmsg = "Expected start of line" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if col(loc, instring) == 1: 
+            return loc, [] 
+        raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class LineEnd(_PositionToken): 
+    """ 
+    Matches if current position is at the end of a line within the parse string 
+    """ 
+    def __init__( self ): 
+        super(LineEnd,self).__init__() 
+        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") ) 
+        self.errmsg = "Expected end of line" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if loc<len(instring): 
+            if instring[loc] == "\n": 
+                return loc+1, "\n" 
+            else: 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        elif loc == len(instring): 
+            return loc+1, [] 
+        else: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class StringStart(_PositionToken): 
+    """ 
+    Matches if current position is at the beginning of the parse string 
+    """ 
+    def __init__( self ): 
+        super(StringStart,self).__init__() 
+        self.errmsg = "Expected start of text" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if loc != 0: 
+            # see if entire string up to here is just whitespace and ignoreables 
+            if loc != self.preParse( instring, 0 ): 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+class StringEnd(_PositionToken): 
+    """ 
+    Matches if current position is at the end of the parse string 
+    """ 
+    def __init__( self ): 
+        super(StringEnd,self).__init__() 
+        self.errmsg = "Expected end of text" 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if loc < len(instring): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+        elif loc == len(instring): 
+            return loc+1, [] 
+        elif loc > len(instring): 
+            return loc, [] 
+        else: 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+class WordStart(_PositionToken): 
+    """ 
+    Matches if the current position is at the beginning of a Word, and 
+    is not preceded by any character in a given set of C{wordChars} 
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions, 
+    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of 
+    the string being parsed, or at the beginning of a line. 
+    """ 
+    def __init__(self, wordChars = printables): 
+        super(WordStart,self).__init__() 
+        self.wordChars = set(wordChars) 
+        self.errmsg = "Not at the start of a word" 
+ 
+    def parseImpl(self, instring, loc, doActions=True ): 
+        if loc != 0: 
+            if (instring[loc-1] in self.wordChars or 
+                instring[loc] not in self.wordChars): 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+class WordEnd(_PositionToken): 
+    """ 
+    Matches if the current position is at the end of a Word, and 
+    is not followed by any character in a given set of C{wordChars} 
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions, 
+    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of 
+    the string being parsed, or at the end of a line. 
+    """ 
+    def __init__(self, wordChars = printables): 
+        super(WordEnd,self).__init__() 
+        self.wordChars = set(wordChars) 
+        self.skipWhitespace = False 
+        self.errmsg = "Not at the end of a word" 
+ 
+    def parseImpl(self, instring, loc, doActions=True ): 
+        instrlen = len(instring) 
+        if instrlen>0 and loc<instrlen: 
+            if (instring[loc] in self.wordChars or 
+                instring[loc-1] not in self.wordChars): 
+                raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+ 
+class ParseExpression(ParserElement): 
+    """ 
+    Abstract subclass of ParserElement, for combining and post-processing parsed tokens. 
+    """ 
+    def __init__( self, exprs, savelist = False ): 
+        super(ParseExpression,self).__init__(savelist) 
+        if isinstance( exprs, _generatorType ): 
+            exprs = list(exprs) 
+ 
+        if isinstance( exprs, basestring ): 
+            self.exprs = [ ParserElement._literalStringClass( exprs ) ] 
+        elif isinstance( exprs, Iterable ): 
+            exprs = list(exprs) 
+            # if sequence of strings provided, wrap with Literal 
+            if all(isinstance(expr, basestring) for expr in exprs): 
+                exprs = map(ParserElement._literalStringClass, exprs) 
+            self.exprs = list(exprs) 
+        else: 
+            try: 
+                self.exprs = list( exprs ) 
+            except TypeError: 
+                self.exprs = [ exprs ] 
+        self.callPreparse = False 
+ 
+    def __getitem__( self, i ): 
+        return self.exprs[i] 
+ 
+    def append( self, other ): 
+        self.exprs.append( other ) 
+        self.strRepr = None 
+        return self 
+ 
+    def leaveWhitespace( self ): 
+        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on 
+           all contained expressions.""" 
+        self.skipWhitespace = False 
+        self.exprs = [ e.copy() for e in self.exprs ] 
+        for e in self.exprs: 
+            e.leaveWhitespace() 
+        return self 
+ 
+    def ignore( self, other ): 
+        if isinstance( other, Suppress ): 
+            if other not in self.ignoreExprs: 
+                super( ParseExpression, self).ignore( other ) 
+                for e in self.exprs: 
+                    e.ignore( self.ignoreExprs[-1] ) 
+        else: 
+            super( ParseExpression, self).ignore( other ) 
+            for e in self.exprs: 
+                e.ignore( self.ignoreExprs[-1] ) 
+        return self 
+ 
+    def __str__( self ): 
+        try: 
+            return super(ParseExpression,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) ) 
+        return self.strRepr 
+ 
+    def streamline( self ): 
+        super(ParseExpression,self).streamline() 
+ 
+        for e in self.exprs: 
+            e.streamline() 
+ 
+        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d ) 
+        # but only if there are no parse actions or resultsNames on the nested And's 
+        # (likewise for Or's and MatchFirst's) 
+        if ( len(self.exprs) == 2 ): 
+            other = self.exprs[0] 
+            if ( isinstance( other, self.__class__ ) and 
+                  not(other.parseAction) and 
+                  other.resultsName is None and 
+                  not other.debug ): 
+                self.exprs = other.exprs[:] + [ self.exprs[1] ] 
+                self.strRepr = None 
+                self.mayReturnEmpty |= other.mayReturnEmpty 
+                self.mayIndexError  |= other.mayIndexError 
+ 
+            other = self.exprs[-1] 
+            if ( isinstance( other, self.__class__ ) and 
+                  not(other.parseAction) and 
+                  other.resultsName is None and 
+                  not other.debug ): 
+                self.exprs = self.exprs[:-1] + other.exprs[:] 
+                self.strRepr = None 
+                self.mayReturnEmpty |= other.mayReturnEmpty 
+                self.mayIndexError  |= other.mayIndexError 
+ 
+        self.errmsg = "Expected " + _ustr(self) 
+         
+        return self 
+ 
+    def setResultsName( self, name, listAllMatches=False ): 
+        ret = super(ParseExpression,self).setResultsName(name,listAllMatches) 
+        return ret 
+ 
+    def validate( self, validateTrace=[] ): 
+        tmp = validateTrace[:]+[self] 
+        for e in self.exprs: 
+            e.validate(tmp) 
+        self.checkRecursion( [] ) 
+         
+    def copy(self): 
+        ret = super(ParseExpression,self).copy() 
+        ret.exprs = [e.copy() for e in self.exprs] 
+        return ret 
+ 
+class And(ParseExpression): 
+    """ 
+    Requires all given C{ParseExpression}s to be found in the given order. 
+    Expressions may be separated by whitespace. 
+    May be constructed using the C{'+'} operator. 
+    May also be constructed using the C{'-'} operator, which will suppress backtracking. 
+ 
+    Example:: 
+        integer = Word(nums) 
+        name_expr = OneOrMore(Word(alphas)) 
+ 
+        expr = And([integer("id"),name_expr("name"),integer("age")]) 
+        # more easily written as: 
+        expr = integer("id") + name_expr("name") + integer("age") 
+    """ 
+ 
+    class _ErrorStop(Empty): 
+        def __init__(self, *args, **kwargs): 
+            super(And._ErrorStop,self).__init__(*args, **kwargs) 
+            self.name = '-' 
+            self.leaveWhitespace() 
+ 
+    def __init__( self, exprs, savelist = True ): 
+        super(And,self).__init__(exprs, savelist) 
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs) 
+        self.setWhitespaceChars( self.exprs[0].whiteChars ) 
+        self.skipWhitespace = self.exprs[0].skipWhitespace 
+        self.callPreparse = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        # pass False as last arg to _parse for first element, since we already 
+        # pre-parsed the string as part of our And pre-parsing 
+        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False ) 
+        errorStop = False 
+        for e in self.exprs[1:]: 
+            if isinstance(e, And._ErrorStop): 
+                errorStop = True 
+                continue 
+            if errorStop: 
+                try: 
+                    loc, exprtokens = e._parse( instring, loc, doActions ) 
+                except ParseSyntaxException: 
+                    raise 
+                except ParseBaseException as pe: 
+                    pe.__traceback__ = None 
+                    raise ParseSyntaxException._from_exception(pe) 
+                except IndexError: 
+                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self) 
+            else: 
+                loc, exprtokens = e._parse( instring, loc, doActions ) 
+            if exprtokens or exprtokens.haskeys(): 
+                resultlist += exprtokens 
+        return loc, resultlist 
+ 
+    def __iadd__(self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        return self.append( other ) #And( [ self, other ] ) 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+            if not e.mayReturnEmpty: 
+                break 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+ 
+class Or(ParseExpression): 
+    """ 
+    Requires that at least one C{ParseExpression} is found. 
+    If two expressions match, the expression that matches the longest string will be used. 
+    May be constructed using the C{'^'} operator. 
+ 
+    Example:: 
+        # construct Or using '^' operator 
+         
+        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums)) 
+        print(number.searchString("123 3.1416 789")) 
+    prints:: 
+        [['123'], ['3.1416'], ['789']] 
+    """ 
+    def __init__( self, exprs, savelist = False ): 
+        super(Or,self).__init__(exprs, savelist) 
+        if self.exprs: 
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs) 
+        else: 
+            self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        maxExcLoc = -1 
+        maxException = None 
+        matches = [] 
+        for e in self.exprs: 
+            try: 
+                loc2 = e.tryParse( instring, loc ) 
+            except ParseException as err: 
+                err.__traceback__ = None 
+                if err.loc > maxExcLoc: 
+                    maxException = err 
+                    maxExcLoc = err.loc 
+            except IndexError: 
+                if len(instring) > maxExcLoc: 
+                    maxException = ParseException(instring,len(instring),e.errmsg,self) 
+                    maxExcLoc = len(instring) 
+            else: 
+                # save match among all matches, to retry longest to shortest 
+                matches.append((loc2, e)) 
+ 
+        if matches: 
+            matches.sort(key=lambda x: -x[0]) 
+            for _,e in matches: 
+                try: 
+                    return e._parse( instring, loc, doActions ) 
+                except ParseException as err: 
+                    err.__traceback__ = None 
+                    if err.loc > maxExcLoc: 
+                        maxException = err 
+                        maxExcLoc = err.loc 
+ 
+        if maxException is not None: 
+            maxException.msg = self.errmsg 
+            raise maxException 
+        else: 
+            raise ParseException(instring, loc, "no defined alternatives to match", self) 
+ 
+ 
+    def __ixor__(self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        return self.append( other ) #Or( [ self, other ] ) 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+ 
+ 
+class MatchFirst(ParseExpression): 
+    """ 
+    Requires that at least one C{ParseExpression} is found. 
+    If two expressions match, the first one listed is the one that will match. 
+    May be constructed using the C{'|'} operator. 
+ 
+    Example:: 
+        # construct MatchFirst using '|' operator 
+         
+        # watch the order of expressions to match 
+        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums)) 
+        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']] 
+ 
+        # put more selective expression first 
+        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums) 
+        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']] 
+    """ 
+    def __init__( self, exprs, savelist = False ): 
+        super(MatchFirst,self).__init__(exprs, savelist) 
+        if self.exprs: 
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs) 
+        else: 
+            self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        maxExcLoc = -1 
+        maxException = None 
+        for e in self.exprs: 
+            try: 
+                ret = e._parse( instring, loc, doActions ) 
+                return ret 
+            except ParseException as err: 
+                if err.loc > maxExcLoc: 
+                    maxException = err 
+                    maxExcLoc = err.loc 
+            except IndexError: 
+                if len(instring) > maxExcLoc: 
+                    maxException = ParseException(instring,len(instring),e.errmsg,self) 
+                    maxExcLoc = len(instring) 
+ 
+        # only got here if no expression matched, raise exception for match that made it the furthest 
+        else: 
+            if maxException is not None: 
+                maxException.msg = self.errmsg 
+                raise maxException 
+            else: 
+                raise ParseException(instring, loc, "no defined alternatives to match", self) 
+ 
+    def __ior__(self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass( other ) 
+        return self.append( other ) #MatchFirst( [ self, other ] ) 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+ 
+ 
+class Each(ParseExpression): 
+    """ 
+    Requires all given C{ParseExpression}s to be found, but in any order. 
+    Expressions may be separated by whitespace. 
+    May be constructed using the C{'&'} operator. 
+ 
+    Example:: 
+        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN") 
+        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON") 
+        integer = Word(nums) 
+        shape_attr = "shape:" + shape_type("shape") 
+        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn") 
+        color_attr = "color:" + color("color") 
+        size_attr = "size:" + integer("size") 
+ 
+        # use Each (using operator '&') to accept attributes in any order  
+        # (shape and posn are required, color and size are optional) 
+        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr) 
+ 
+        shape_spec.runTests(''' 
+            shape: SQUARE color: BLACK posn: 100, 120 
+            shape: CIRCLE size: 50 color: BLUE posn: 50,80 
+            color:GREEN size:20 shape:TRIANGLE posn:20,40 
+            ''' 
+            ) 
+    prints:: 
+        shape: SQUARE color: BLACK posn: 100, 120 
+        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']] 
+        - color: BLACK 
+        - posn: ['100', ',', '120'] 
+          - x: 100 
+          - y: 120 
+        - shape: SQUARE 
+ 
+ 
+        shape: CIRCLE size: 50 color: BLUE posn: 50,80 
+        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']] 
+        - color: BLUE 
+        - posn: ['50', ',', '80'] 
+          - x: 50 
+          - y: 80 
+        - shape: CIRCLE 
+        - size: 50 
+ 
+ 
+        color: GREEN size: 20 shape: TRIANGLE posn: 20,40 
+        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']] 
+        - color: GREEN 
+        - posn: ['20', ',', '40'] 
+          - x: 20 
+          - y: 40 
+        - shape: TRIANGLE 
+        - size: 20 
+    """ 
+    def __init__( self, exprs, savelist = True ): 
+        super(Each,self).__init__(exprs, savelist) 
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs) 
+        self.skipWhitespace = True 
+        self.initExprGroups = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.initExprGroups: 
+            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional)) 
+            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ] 
+            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)] 
+            self.optionals = opt1 + opt2 
+            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ] 
+            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ] 
+            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ] 
+            self.required += self.multirequired 
+            self.initExprGroups = False 
+        tmpLoc = loc 
+        tmpReqd = self.required[:] 
+        tmpOpt  = self.optionals[:] 
+        matchOrder = [] 
+ 
+        keepMatching = True 
+        while keepMatching: 
+            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired 
+            failed = [] 
+            for e in tmpExprs: 
+                try: 
+                    tmpLoc = e.tryParse( instring, tmpLoc ) 
+                except ParseException: 
+                    failed.append(e) 
+                else: 
+                    matchOrder.append(self.opt1map.get(id(e),e)) 
+                    if e in tmpReqd: 
+                        tmpReqd.remove(e) 
+                    elif e in tmpOpt: 
+                        tmpOpt.remove(e) 
+            if len(failed) == len(tmpExprs): 
+                keepMatching = False 
+ 
+        if tmpReqd: 
+            missing = ", ".join(_ustr(e) for e in tmpReqd) 
+            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing ) 
+ 
+        # add any unmatched Optionals, in case they have default values defined 
+        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt] 
+ 
+        resultlist = [] 
+        for e in matchOrder: 
+            loc,results = e._parse(instring,loc,doActions) 
+            resultlist.append(results) 
+ 
+        finalResults = sum(resultlist, ParseResults([])) 
+        return loc, finalResults 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}" 
+ 
+        return self.strRepr 
+ 
+    def checkRecursion( self, parseElementList ): 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        for e in self.exprs: 
+            e.checkRecursion( subRecCheckList ) 
+ 
+ 
+class ParseElementEnhance(ParserElement): 
+    """ 
+    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens. 
+    """ 
+    def __init__( self, expr, savelist=False ): 
+        super(ParseElementEnhance,self).__init__(savelist) 
+        if isinstance( expr, basestring ): 
+            if issubclass(ParserElement._literalStringClass, Token): 
+                expr = ParserElement._literalStringClass(expr) 
+            else: 
+                expr = ParserElement._literalStringClass(Literal(expr)) 
+        self.expr = expr 
+        self.strRepr = None 
+        if expr is not None: 
+            self.mayIndexError = expr.mayIndexError 
+            self.mayReturnEmpty = expr.mayReturnEmpty 
+            self.setWhitespaceChars( expr.whiteChars ) 
+            self.skipWhitespace = expr.skipWhitespace 
+            self.saveAsList = expr.saveAsList 
+            self.callPreparse = expr.callPreparse 
+            self.ignoreExprs.extend(expr.ignoreExprs) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.expr is not None: 
+            return self.expr._parse( instring, loc, doActions, callPreParse=False ) 
+        else: 
+            raise ParseException("",loc,self.errmsg,self) 
+ 
+    def leaveWhitespace( self ): 
+        self.skipWhitespace = False 
+        self.expr = self.expr.copy() 
+        if self.expr is not None: 
+            self.expr.leaveWhitespace() 
+        return self 
+ 
+    def ignore( self, other ): 
+        if isinstance( other, Suppress ): 
+            if other not in self.ignoreExprs: 
+                super( ParseElementEnhance, self).ignore( other ) 
+                if self.expr is not None: 
+                    self.expr.ignore( self.ignoreExprs[-1] ) 
+        else: 
+            super( ParseElementEnhance, self).ignore( other ) 
+            if self.expr is not None: 
+                self.expr.ignore( self.ignoreExprs[-1] ) 
+        return self 
+ 
+    def streamline( self ): 
+        super(ParseElementEnhance,self).streamline() 
+        if self.expr is not None: 
+            self.expr.streamline() 
+        return self 
+ 
+    def checkRecursion( self, parseElementList ): 
+        if self in parseElementList: 
+            raise RecursiveGrammarException( parseElementList+[self] ) 
+        subRecCheckList = parseElementList[:] + [ self ] 
+        if self.expr is not None: 
+            self.expr.checkRecursion( subRecCheckList ) 
+ 
+    def validate( self, validateTrace=[] ): 
+        tmp = validateTrace[:]+[self] 
+        if self.expr is not None: 
+            self.expr.validate(tmp) 
+        self.checkRecursion( [] ) 
+ 
+    def __str__( self ): 
+        try: 
+            return super(ParseElementEnhance,self).__str__() 
+        except Exception: 
+            pass 
+ 
+        if self.strRepr is None and self.expr is not None: 
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) ) 
+        return self.strRepr 
+ 
+ 
+class FollowedBy(ParseElementEnhance): 
+    """ 
+    Lookahead matching of the given parse expression.  C{FollowedBy} 
+    does I{not} advance the parsing position within the input string, it only 
+    verifies that the specified parse expression matches at the current 
+    position.  C{FollowedBy} always returns a null token list. 
+ 
+    Example:: 
+        # use FollowedBy to match a label only if it is followed by a ':' 
+        data_word = Word(alphas) 
+        label = data_word + FollowedBy(':') 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+         
+        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint() 
+    prints:: 
+        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']] 
+    """ 
+    def __init__( self, expr ): 
+        super(FollowedBy,self).__init__(expr) 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        self.expr.tryParse( instring, loc ) 
+        return loc, [] 
+ 
+ 
+class NotAny(ParseElementEnhance): 
+    """ 
+    Lookahead to disallow matching with the given parse expression.  C{NotAny} 
+    does I{not} advance the parsing position within the input string, it only 
+    verifies that the specified parse expression does I{not} match at the current 
+    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny} 
+    always returns a null token list.  May be constructed using the '~' operator. 
+ 
+    Example:: 
+         
+    """ 
+    def __init__( self, expr ): 
+        super(NotAny,self).__init__(expr) 
+        #~ self.leaveWhitespace() 
+        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs 
+        self.mayReturnEmpty = True 
+        self.errmsg = "Found unwanted token, "+_ustr(self.expr) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        if self.expr.canParseNext(instring, loc): 
+            raise ParseException(instring, loc, self.errmsg, self) 
+        return loc, [] 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "~{" + _ustr(self.expr) + "}" 
+ 
+        return self.strRepr 
+ 
+class _MultipleMatch(ParseElementEnhance): 
+    def __init__( self, expr, stopOn=None): 
+        super(_MultipleMatch, self).__init__(expr) 
+        self.saveAsList = True 
+        ender = stopOn 
+        if isinstance(ender, basestring): 
+            ender = ParserElement._literalStringClass(ender) 
+        self.not_ender = ~ender if ender is not None else None 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        self_expr_parse = self.expr._parse 
+        self_skip_ignorables = self._skipIgnorables 
+        check_ender = self.not_ender is not None 
+        if check_ender: 
+            try_not_ender = self.not_ender.tryParse 
+         
+        # must be at least one (but first see if we are the stopOn sentinel; 
+        # if so, fail) 
+        if check_ender: 
+            try_not_ender(instring, loc) 
+        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False ) 
+        try: 
+            hasIgnoreExprs = (not not self.ignoreExprs) 
+            while 1: 
+                if check_ender: 
+                    try_not_ender(instring, loc) 
+                if hasIgnoreExprs: 
+                    preloc = self_skip_ignorables( instring, loc ) 
+                else: 
+                    preloc = loc 
+                loc, tmptokens = self_expr_parse( instring, preloc, doActions ) 
+                if tmptokens or tmptokens.haskeys(): 
+                    tokens += tmptokens 
+        except (ParseException,IndexError): 
+            pass 
+ 
+        return loc, tokens 
+         
+class OneOrMore(_MultipleMatch): 
+    """ 
+    Repetition of one or more of the given expression. 
+     
+    Parameters: 
+     - expr - expression that must match one or more times 
+     - stopOn - (default=C{None}) - expression for a terminating sentinel 
+          (only required if the sentinel would ordinarily match the repetition  
+          expression)           
+ 
+    Example:: 
+        data_word = Word(alphas) 
+        label = data_word + FollowedBy(':') 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) 
+ 
+        text = "shape: SQUARE posn: upper left color: BLACK" 
+        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']] 
+ 
+        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']] 
+         
+        # could also be written as 
+        (attr_expr * (1,)).parseString(text).pprint() 
+    """ 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "{" + _ustr(self.expr) + "}..." 
+ 
+        return self.strRepr 
+ 
+class ZeroOrMore(_MultipleMatch): 
+    """ 
+    Optional repetition of zero or more of the given expression. 
+     
+    Parameters: 
+     - expr - expression that must match zero or more times 
+     - stopOn - (default=C{None}) - expression for a terminating sentinel 
+          (only required if the sentinel would ordinarily match the repetition  
+          expression)           
+ 
+    Example: similar to L{OneOrMore} 
+    """ 
+    def __init__( self, expr, stopOn=None): 
+        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn) 
+        self.mayReturnEmpty = True 
+         
+    def parseImpl( self, instring, loc, doActions=True ): 
+        try: 
+            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions) 
+        except (ParseException,IndexError): 
+            return loc, [] 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "[" + _ustr(self.expr) + "]..." 
+ 
+        return self.strRepr 
+ 
+class _NullToken(object): 
+    def __bool__(self): 
+        return False 
+    __nonzero__ = __bool__ 
+    def __str__(self): 
+        return "" 
+ 
+_optionalNotMatched = _NullToken() 
+class Optional(ParseElementEnhance): 
+    """ 
+    Optional matching of the given expression. 
+ 
+    Parameters: 
+     - expr - expression that must match zero or more times 
+     - default (optional) - value to be returned if the optional expression is not found. 
+ 
+    Example:: 
+        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier 
+        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4))) 
+        zip.runTests(''' 
+            # traditional ZIP code 
+            12345 
+             
+            # ZIP+4 form 
+            12101-0001 
+             
+            # invalid ZIP 
+            98765- 
+            ''') 
+    prints:: 
+        # traditional ZIP code 
+        12345 
+        ['12345'] 
+ 
+        # ZIP+4 form 
+        12101-0001 
+        ['12101-0001'] 
+ 
+        # invalid ZIP 
+        98765- 
+             ^ 
+        FAIL: Expected end of text (at char 5), (line:1, col:6) 
+    """ 
+    def __init__( self, expr, default=_optionalNotMatched ): 
+        super(Optional,self).__init__( expr, savelist=False ) 
+        self.saveAsList = self.expr.saveAsList 
+        self.defaultValue = default 
+        self.mayReturnEmpty = True 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        try: 
+            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False ) 
+        except (ParseException,IndexError): 
+            if self.defaultValue is not _optionalNotMatched: 
+                if self.expr.resultsName: 
+                    tokens = ParseResults([ self.defaultValue ]) 
+                    tokens[self.expr.resultsName] = self.defaultValue 
+                else: 
+                    tokens = [ self.defaultValue ] 
+            else: 
+                tokens = [] 
+        return loc, tokens 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+ 
+        if self.strRepr is None: 
+            self.strRepr = "[" + _ustr(self.expr) + "]" 
+ 
+        return self.strRepr 
+ 
+class SkipTo(ParseElementEnhance): 
+    """ 
+    Token for skipping over all undefined text until the matched expression is found. 
+ 
+    Parameters: 
+     - expr - target expression marking the end of the data to be skipped 
+     - include - (default=C{False}) if True, the target expression is also parsed  
+          (the skipped text and target expression are returned as a 2-element list). 
+     - ignore - (default=C{None}) used to define grammars (typically quoted strings and  
+          comments) that might contain false matches to the target expression 
+     - failOn - (default=C{None}) define expressions that are not allowed to be  
+          included in the skipped test; if found before the target expression is found,  
+          the SkipTo is not a match 
+ 
+    Example:: 
+        report = ''' 
+            Outstanding Issues Report - 1 Jan 2000 
+ 
+               # | Severity | Description                               |  Days Open 
+            -----+----------+-------------------------------------------+----------- 
+             101 | Critical | Intermittent system crash                 |          6 
+              94 | Cosmetic | Spelling error on Login ('log|n')         |         14 
+              79 | Minor    | System slow when running too many reports |         47 
+            ''' 
+        integer = Word(nums) 
+        SEP = Suppress('|') 
+        # use SkipTo to simply match everything up until the next SEP 
+        # - ignore quoted strings, so that a '|' character inside a quoted string does not match 
+        # - parse action will call token.strip() for each matched token, i.e., the description body 
+        string_data = SkipTo(SEP, ignore=quotedString) 
+        string_data.setParseAction(tokenMap(str.strip)) 
+        ticket_expr = (integer("issue_num") + SEP  
+                      + string_data("sev") + SEP  
+                      + string_data("desc") + SEP  
+                      + integer("days_open")) 
+         
+        for tkt in ticket_expr.searchString(report): 
+            print tkt.dump() 
+    prints:: 
+        ['101', 'Critical', 'Intermittent system crash', '6'] 
+        - days_open: 6 
+        - desc: Intermittent system crash 
+        - issue_num: 101 
+        - sev: Critical 
+        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14'] 
+        - days_open: 14 
+        - desc: Spelling error on Login ('log|n') 
+        - issue_num: 94 
+        - sev: Cosmetic 
+        ['79', 'Minor', 'System slow when running too many reports', '47'] 
+        - days_open: 47 
+        - desc: System slow when running too many reports 
+        - issue_num: 79 
+        - sev: Minor 
+    """ 
+    def __init__( self, other, include=False, ignore=None, failOn=None ): 
+        super( SkipTo, self ).__init__( other ) 
+        self.ignoreExpr = ignore 
+        self.mayReturnEmpty = True 
+        self.mayIndexError = False 
+        self.includeMatch = include 
+        self.asList = False 
+        if isinstance(failOn, basestring): 
+            self.failOn = ParserElement._literalStringClass(failOn) 
+        else: 
+            self.failOn = failOn 
+        self.errmsg = "No match found for "+_ustr(self.expr) 
+ 
+    def parseImpl( self, instring, loc, doActions=True ): 
+        startloc = loc 
+        instrlen = len(instring) 
+        expr = self.expr 
+        expr_parse = self.expr._parse 
+        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None 
+        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None 
+         
+        tmploc = loc 
+        while tmploc <= instrlen: 
+            if self_failOn_canParseNext is not None: 
+                # break if failOn expression matches 
+                if self_failOn_canParseNext(instring, tmploc): 
+                    break 
+                     
+            if self_ignoreExpr_tryParse is not None: 
+                # advance past ignore expressions 
+                while 1: 
+                    try: 
+                        tmploc = self_ignoreExpr_tryParse(instring, tmploc) 
+                    except ParseBaseException: 
+                        break 
+             
+            try: 
+                expr_parse(instring, tmploc, doActions=False, callPreParse=False) 
+            except (ParseException, IndexError): 
+                # no match, advance loc in string 
+                tmploc += 1 
+            else: 
+                # matched skipto expr, done 
+                break 
+ 
+        else: 
+            # ran off the end of the input string without matching skipto expr, fail 
+            raise ParseException(instring, loc, self.errmsg, self) 
+ 
+        # build up return values 
+        loc = tmploc 
+        skiptext = instring[startloc:loc] 
+        skipresult = ParseResults(skiptext) 
+         
+        if self.includeMatch: 
+            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False) 
+            skipresult += mat 
+ 
+        return loc, skipresult 
+ 
+class Forward(ParseElementEnhance): 
+    """ 
+    Forward declaration of an expression to be defined later - 
+    used for recursive grammars, such as algebraic infix notation. 
+    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator. 
+ 
+    Note: take care when assigning to C{Forward} not to overlook precedence of operators. 
+    Specifically, '|' has a lower precedence than '<<', so that:: 
+        fwdExpr << a | b | c 
+    will actually be evaluated as:: 
+        (fwdExpr << a) | b | c 
+    thereby leaving b and c out as parseable alternatives.  It is recommended that you 
+    explicitly group the values inserted into the C{Forward}:: 
+        fwdExpr << (a | b | c) 
+    Converting to use the '<<=' operator instead will avoid this problem. 
+ 
+    See L{ParseResults.pprint} for an example of a recursive parser created using 
+    C{Forward}. 
+    """ 
+    def __init__( self, other=None ): 
+        super(Forward,self).__init__( other, savelist=False ) 
+ 
+    def __lshift__( self, other ): 
+        if isinstance( other, basestring ): 
+            other = ParserElement._literalStringClass(other) 
+        self.expr = other 
+        self.strRepr = None 
+        self.mayIndexError = self.expr.mayIndexError 
+        self.mayReturnEmpty = self.expr.mayReturnEmpty 
+        self.setWhitespaceChars( self.expr.whiteChars ) 
+        self.skipWhitespace = self.expr.skipWhitespace 
+        self.saveAsList = self.expr.saveAsList 
+        self.ignoreExprs.extend(self.expr.ignoreExprs) 
+        return self 
+         
+    def __ilshift__(self, other): 
+        return self << other 
+     
+    def leaveWhitespace( self ): 
+        self.skipWhitespace = False 
+        return self 
+ 
+    def streamline( self ): 
+        if not self.streamlined: 
+            self.streamlined = True 
+            if self.expr is not None: 
+                self.expr.streamline() 
+        return self 
+ 
+    def validate( self, validateTrace=[] ): 
+        if self not in validateTrace: 
+            tmp = validateTrace[:]+[self] 
+            if self.expr is not None: 
+                self.expr.validate(tmp) 
+        self.checkRecursion([]) 
+ 
+    def __str__( self ): 
+        if hasattr(self,"name"): 
+            return self.name 
+        return self.__class__.__name__ + ": ..." 
+ 
+        # stubbed out for now - creates awful memory and perf issues 
+        self._revertClass = self.__class__ 
+        self.__class__ = _ForwardNoRecurse 
+        try: 
+            if self.expr is not None: 
+                retString = _ustr(self.expr) 
+            else: 
+                retString = "None" 
+        finally: 
+            self.__class__ = self._revertClass 
+        return self.__class__.__name__ + ": " + retString 
+ 
+    def copy(self): 
+        if self.expr is not None: 
+            return super(Forward,self).copy() 
+        else: 
+            ret = Forward() 
+            ret <<= self 
+            return ret 
+ 
+class _ForwardNoRecurse(Forward): 
+    def __str__( self ): 
+        return "..." 
+ 
+class TokenConverter(ParseElementEnhance): 
+    """ 
+    Abstract subclass of C{ParseExpression}, for converting parsed results. 
+    """ 
+    def __init__( self, expr, savelist=False ): 
+        super(TokenConverter,self).__init__( expr )#, savelist ) 
+        self.saveAsList = False 
+ 
+class Combine(TokenConverter): 
+    """ 
+    Converter to concatenate all matching tokens to a single string. 
+    By default, the matching patterns must also be contiguous in the input string; 
+    this can be disabled by specifying C{'adjacent=False'} in the constructor. 
+ 
+    Example:: 
+        real = Word(nums) + '.' + Word(nums) 
+        print(real.parseString('3.1416')) # -> ['3', '.', '1416'] 
+        # will also erroneously match the following 
+        print(real.parseString('3. 1416')) # -> ['3', '.', '1416'] 
+ 
+        real = Combine(Word(nums) + '.' + Word(nums)) 
+        print(real.parseString('3.1416')) # -> ['3.1416'] 
+        # no match when there are internal spaces 
+        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...) 
+    """ 
+    def __init__( self, expr, joinString="", adjacent=True ): 
+        super(Combine,self).__init__( expr ) 
+        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself 
+        if adjacent: 
+            self.leaveWhitespace() 
+        self.adjacent = adjacent 
+        self.skipWhitespace = True 
+        self.joinString = joinString 
+        self.callPreparse = True 
+ 
+    def ignore( self, other ): 
+        if self.adjacent: 
+            ParserElement.ignore(self, other) 
+        else: 
+            super( Combine, self).ignore( other ) 
+        return self 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        retToks = tokenlist.copy() 
+        del retToks[:] 
+        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults) 
+ 
+        if self.resultsName and retToks.haskeys(): 
+            return [ retToks ] 
+        else: 
+            return retToks 
+ 
+class Group(TokenConverter): 
+    """ 
+    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions. 
+ 
+    Example:: 
+        ident = Word(alphas) 
+        num = Word(nums) 
+        term = ident | num 
+        func = ident + Optional(delimitedList(term)) 
+        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100'] 
+ 
+        func = ident + Group(Optional(delimitedList(term))) 
+        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']] 
+    """ 
+    def __init__( self, expr ): 
+        super(Group,self).__init__( expr ) 
+        self.saveAsList = True 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        return [ tokenlist ] 
+ 
+class Dict(TokenConverter): 
+    """ 
+    Converter to return a repetitive expression as a list, but also as a dictionary. 
+    Each element can also be referenced using the first token in the expression as its key. 
+    Useful for tabular report scraping when the first column can be used as a item key. 
+ 
+    Example:: 
+        data_word = Word(alphas) 
+        label = data_word + FollowedBy(':') 
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join)) 
+ 
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap" 
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+         
+        # print attributes as plain groups 
+        print(OneOrMore(attr_expr).parseString(text).dump()) 
+         
+        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names 
+        result = Dict(OneOrMore(Group(attr_expr))).parseString(text) 
+        print(result.dump()) 
+         
+        # access named fields as dict entries, or output as dict 
+        print(result['shape'])         
+        print(result.asDict()) 
+    prints:: 
+        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap'] 
+ 
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] 
+        - color: light blue 
+        - posn: upper left 
+        - shape: SQUARE 
+        - texture: burlap 
+        SQUARE 
+        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'} 
+    See more examples at L{ParseResults} of accessing fields by results name. 
+    """ 
+    def __init__( self, expr ): 
+        super(Dict,self).__init__( expr ) 
+        self.saveAsList = True 
+ 
+    def postParse( self, instring, loc, tokenlist ): 
+        for i,tok in enumerate(tokenlist): 
+            if len(tok) == 0: 
+                continue 
+            ikey = tok[0] 
+            if isinstance(ikey,int): 
+                ikey = _ustr(tok[0]).strip() 
+            if len(tok)==1: 
+                tokenlist[ikey] = _ParseResultsWithOffset("",i) 
+            elif len(tok)==2 and not isinstance(tok[1],ParseResults): 
+                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i) 
+            else: 
+                dictvalue = tok.copy() #ParseResults(i) 
+                del dictvalue[0] 
+                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()): 
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i) 
+                else: 
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i) 
+ 
+        if self.resultsName: 
+            return [ tokenlist ] 
+        else: 
+            return tokenlist 
+ 
+ 
+class Suppress(TokenConverter): 
+    """ 
+    Converter for ignoring the results of a parsed expression. 
+ 
+    Example:: 
+        source = "a, b, c,d" 
+        wd = Word(alphas) 
+        wd_list1 = wd + ZeroOrMore(',' + wd) 
+        print(wd_list1.parseString(source)) 
+ 
+        # often, delimiters that are useful during parsing are just in the 
+        # way afterward - use Suppress to keep them out of the parsed output 
+        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd) 
+        print(wd_list2.parseString(source)) 
+    prints:: 
+        ['a', ',', 'b', ',', 'c', ',', 'd'] 
+        ['a', 'b', 'c', 'd'] 
+    (See also L{delimitedList}.) 
+    """ 
+    def postParse( self, instring, loc, tokenlist ): 
+        return [] 
+ 
+    def suppress( self ): 
+        return self 
+ 
+ 
+class OnlyOnce(object): 
+    """ 
+    Wrapper for parse actions, to ensure they are only called once. 
+    """ 
+    def __init__(self, methodCall): 
+        self.callable = _trim_arity(methodCall) 
+        self.called = False 
+    def __call__(self,s,l,t): 
+        if not self.called: 
+            results = self.callable(s,l,t) 
+            self.called = True 
+            return results 
+        raise ParseException(s,l,"") 
+    def reset(self): 
+        self.called = False 
+ 
+def traceParseAction(f): 
+    """ 
+    Decorator for debugging parse actions.  
+     
+    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".} 
+    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised. 
+ 
+    Example:: 
+        wd = Word(alphas) 
+ 
+        @traceParseAction 
+        def remove_duplicate_chars(tokens): 
+            return ''.join(sorted(set(''.join(tokens)))) 
+ 
+        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars) 
+        print(wds.parseString("slkdjs sld sldd sdlf sdljf")) 
+    prints:: 
+        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {})) 
+        <<leaving remove_duplicate_chars (ret: 'dfjkls') 
+        ['dfjkls'] 
+    """ 
+    f = _trim_arity(f) 
+    def z(*paArgs): 
+        thisFunc = f.__name__ 
+        s,l,t = paArgs[-3:] 
+        if len(paArgs)>3: 
+            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc 
+        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) ) 
+        try: 
+            ret = f(*paArgs) 
+        except Exception as exc: 
+            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) ) 
+            raise 
+        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) ) 
+        return ret 
+    try: 
+        z.__name__ = f.__name__ 
+    except AttributeError: 
+        pass 
+    return z 
+ 
+# 
+# global helpers 
+# 
+def delimitedList( expr, delim=",", combine=False ): 
+    """ 
+    Helper to define a delimited list of expressions - the delimiter defaults to ','. 
+    By default, the list elements and delimiters can have intervening whitespace, and 
+    comments, but this can be overridden by passing C{combine=True} in the constructor. 
+    If C{combine} is set to C{True}, the matching tokens are returned as a single token 
+    string, with the delimiters included; otherwise, the matching tokens are returned 
+    as a list of tokens, with the delimiters suppressed. 
+ 
+    Example:: 
+        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc'] 
+        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE'] 
+    """ 
+    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..." 
+    if combine: 
+        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName) 
+    else: 
+        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName) 
+ 
+def countedArray( expr, intExpr=None ): 
+    """ 
+    Helper to define a counted list of expressions. 
+    This helper defines a pattern of the form:: 
+        integer expr expr expr... 
+    where the leading integer tells how many expr expressions follow. 
+    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed. 
+     
+    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value. 
+ 
+    Example:: 
+        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd'] 
+ 
+        # in this parser, the leading integer value is given in binary, 
+        # '10' indicating that 2 values are in the array 
+        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2)) 
+        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd'] 
+    """ 
+    arrayExpr = Forward() 
+    def countFieldParseAction(s,l,t): 
+        n = t[0] 
+        arrayExpr << (n and Group(And([expr]*n)) or Group(empty)) 
+        return [] 
+    if intExpr is None: 
+        intExpr = Word(nums).setParseAction(lambda t:int(t[0])) 
+    else: 
+        intExpr = intExpr.copy() 
+    intExpr.setName("arrayLen") 
+    intExpr.addParseAction(countFieldParseAction, callDuringTry=True) 
+    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...') 
+ 
+def _flatten(L): 
+    ret = [] 
+    for i in L: 
+        if isinstance(i,list): 
+            ret.extend(_flatten(i)) 
+        else: 
+            ret.append(i) 
+    return ret 
+ 
+def matchPreviousLiteral(expr): 
+    """ 
+    Helper to define an expression that is indirectly defined from 
+    the tokens matched in a previous expression, that is, it looks 
+    for a 'repeat' of a previous expression.  For example:: 
+        first = Word(nums) 
+        second = matchPreviousLiteral(first) 
+        matchExpr = first + ":" + second 
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a 
+    previous literal, will also match the leading C{"1:1"} in C{"1:10"}. 
+    If this is not desired, use C{matchPreviousExpr}. 
+    Do I{not} use with packrat parsing enabled. 
+    """ 
+    rep = Forward() 
+    def copyTokenToRepeater(s,l,t): 
+        if t: 
+            if len(t) == 1: 
+                rep << t[0] 
+            else: 
+                # flatten t tokens 
+                tflat = _flatten(t.asList()) 
+                rep << And(Literal(tt) for tt in tflat) 
+        else: 
+            rep << Empty() 
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True) 
+    rep.setName('(prev) ' + _ustr(expr)) 
+    return rep 
+ 
+def matchPreviousExpr(expr): 
+    """ 
+    Helper to define an expression that is indirectly defined from 
+    the tokens matched in a previous expression, that is, it looks 
+    for a 'repeat' of a previous expression.  For example:: 
+        first = Word(nums) 
+        second = matchPreviousExpr(first) 
+        matchExpr = first + ":" + second 
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by 
+    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"}; 
+    the expressions are evaluated first, and then compared, so 
+    C{"1"} is compared with C{"10"}. 
+    Do I{not} use with packrat parsing enabled. 
+    """ 
+    rep = Forward() 
+    e2 = expr.copy() 
+    rep <<= e2 
+    def copyTokenToRepeater(s,l,t): 
+        matchTokens = _flatten(t.asList()) 
+        def mustMatchTheseTokens(s,l,t): 
+            theseTokens = _flatten(t.asList()) 
+            if  theseTokens != matchTokens: 
+                raise ParseException("",0,"") 
+        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True ) 
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True) 
+    rep.setName('(prev) ' + _ustr(expr)) 
+    return rep 
+ 
+def _escapeRegexRangeChars(s): 
+    #~  escape these chars: ^-] 
+    for c in r"\^-]": 
+        s = s.replace(c,_bslash+c) 
+    s = s.replace("\n",r"\n") 
+    s = s.replace("\t",r"\t") 
+    return _ustr(s) 
+ 
+def oneOf( strs, caseless=False, useRegex=True ): 
+    """ 
+    Helper to quickly define a set of alternative Literals, and makes sure to do 
+    longest-first testing when there is a conflict, regardless of the input order, 
+    but returns a C{L{MatchFirst}} for best performance. 
+ 
+    Parameters: 
+     - strs - a string of space-delimited literals, or a collection of string literals 
+     - caseless - (default=C{False}) - treat all literals as caseless 
+     - useRegex - (default=C{True}) - as an optimization, will generate a Regex 
+          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or 
+          if creating a C{Regex} raises an exception) 
+ 
+    Example:: 
+        comp_oper = oneOf("< = > <= >= !=") 
+        var = Word(alphas) 
+        number = Word(nums) 
+        term = var | number 
+        comparison_expr = term + comp_oper + term 
+        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12")) 
+    prints:: 
+        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']] 
+    """ 
+    if caseless: 
+        isequal = ( lambda a,b: a.upper() == b.upper() ) 
+        masks = ( lambda a,b: b.upper().startswith(a.upper()) ) 
+        parseElementClass = CaselessLiteral 
+    else: 
+        isequal = ( lambda a,b: a == b ) 
+        masks = ( lambda a,b: b.startswith(a) ) 
+        parseElementClass = Literal 
+ 
+    symbols = [] 
+    if isinstance(strs,basestring): 
+        symbols = strs.split() 
+    elif isinstance(strs, Iterable): 
+        symbols = list(strs) 
+    else: 
+        warnings.warn("Invalid argument to oneOf, expected string or iterable", 
+                SyntaxWarning, stacklevel=2) 
+    if not symbols: 
+        return NoMatch() 
+ 
+    i = 0 
+    while i < len(symbols)-1: 
+        cur = symbols[i] 
+        for j,other in enumerate(symbols[i+1:]): 
+            if ( isequal(other, cur) ): 
+                del symbols[i+j+1] 
+                break 
+            elif ( masks(cur, other) ): 
+                del symbols[i+j+1] 
+                symbols.insert(i,other) 
+                cur = other 
+                break 
+        else: 
+            i += 1 
+ 
+    if not caseless and useRegex: 
+        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] )) 
+        try: 
+            if len(symbols)==len("".join(symbols)): 
+                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols)) 
+            else: 
+                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols)) 
+        except Exception: 
+            warnings.warn("Exception creating Regex for oneOf, building MatchFirst", 
+                    SyntaxWarning, stacklevel=2) 
+ 
+ 
+    # last resort, just use MatchFirst 
+    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols)) 
+ 
+def dictOf( key, value ): 
+    """ 
+    Helper to easily and clearly define a dictionary by specifying the respective patterns 
+    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens 
+    in the proper order.  The key pattern can include delimiting markers or punctuation, 
+    as long as they are suppressed, thereby leaving the significant key text.  The value 
+    pattern can include named results, so that the C{Dict} results can include named token 
+    fields. 
+ 
+    Example:: 
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap" 
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)) 
+        print(OneOrMore(attr_expr).parseString(text).dump()) 
+         
+        attr_label = label 
+        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join) 
+ 
+        # similar to Dict, but simpler call format 
+        result = dictOf(attr_label, attr_value).parseString(text) 
+        print(result.dump()) 
+        print(result['shape']) 
+        print(result.shape)  # object attribute access works too 
+        print(result.asDict()) 
+    prints:: 
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']] 
+        - color: light blue 
+        - posn: upper left 
+        - shape: SQUARE 
+        - texture: burlap 
+        SQUARE 
+        SQUARE 
+        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'} 
+    """ 
+    return Dict( ZeroOrMore( Group ( key + value ) ) ) 
+ 
+def originalTextFor(expr, asString=True): 
+    """ 
+    Helper to return the original, untokenized text for a given expression.  Useful to 
+    restore the parsed fields of an HTML start tag into the raw tag text itself, or to 
+    revert separate tokens with intervening whitespace back to the original matching 
+    input text. By default, returns astring containing the original parsed text.   
+        
+    If the optional C{asString} argument is passed as C{False}, then the return value is a  
+    C{L{ParseResults}} containing any results names that were originally matched, and a  
+    single token containing the original matched text from the input string.  So if  
+    the expression passed to C{L{originalTextFor}} contains expressions with defined 
+    results names, you must set C{asString} to C{False} if you want to preserve those 
+    results name values. 
+ 
+    Example:: 
+        src = "this is test <b> bold <i>text</i> </b> normal text " 
+        for tag in ("b","i"): 
+            opener,closer = makeHTMLTags(tag) 
+            patt = originalTextFor(opener + SkipTo(closer) + closer) 
+            print(patt.searchString(src)[0]) 
+    prints:: 
+        ['<b> bold <i>text</i> </b>'] 
+        ['<i>text</i>'] 
+    """ 
+    locMarker = Empty().setParseAction(lambda s,loc,t: loc) 
+    endlocMarker = locMarker.copy() 
+    endlocMarker.callPreparse = False 
+    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end") 
+    if asString: 
+        extractText = lambda s,l,t: s[t._original_start:t._original_end] 
+    else: 
+        def extractText(s,l,t): 
+            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]] 
+    matchExpr.setParseAction(extractText) 
+    matchExpr.ignoreExprs = expr.ignoreExprs 
+    return matchExpr 
+ 
+def ungroup(expr):  
+    """ 
+    Helper to undo pyparsing's default grouping of And expressions, even 
+    if all but one are non-empty. 
+    """ 
+    return TokenConverter(expr).setParseAction(lambda t:t[0]) 
+ 
+def locatedExpr(expr): 
+    """ 
+    Helper to decorate a returned token with its starting and ending locations in the input string. 
+    This helper adds the following results names: 
+     - locn_start = location where matched expression begins 
+     - locn_end = location where matched expression ends 
+     - value = the actual parsed results 
+ 
+    Be careful if the input text contains C{<TAB>} characters, you may want to call 
+    C{L{ParserElement.parseWithTabs}} 
+ 
+    Example:: 
+        wd = Word(alphas) 
+        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"): 
+            print(match) 
+    prints:: 
+        [[0, 'ljsdf', 5]] 
+        [[8, 'lksdjjf', 15]] 
+        [[18, 'lkkjj', 23]] 
+    """ 
+    locator = Empty().setParseAction(lambda s,l,t: l) 
+    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end")) 
+ 
+ 
+# convenience constants for positional expressions 
+empty       = Empty().setName("empty") 
+lineStart   = LineStart().setName("lineStart") 
+lineEnd     = LineEnd().setName("lineEnd") 
+stringStart = StringStart().setName("stringStart") 
+stringEnd   = StringEnd().setName("stringEnd") 
+ 
+_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1]) 
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16))) 
+_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8))) 
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1) 
+_charRange = Group(_singleChar + Suppress("-") + _singleChar) 
+_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]" 
+ 
+def srange(s): 
+    r""" 
+    Helper to easily define string ranges for use in Word construction.  Borrows 
+    syntax from regexp '[]' string range definitions:: 
+        srange("[0-9]")   -> "0123456789" 
+        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz" 
+        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_" 
+    The input string must be enclosed in []'s, and the returned string is the expanded 
+    character set joined into a single string. 
+    The values enclosed in the []'s may be: 
+     - a single character 
+     - an escaped character with a leading backslash (such as C{\-} or C{\]}) 
+     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character)  
+         (C{\0x##} is also supported for backwards compatibility)  
+     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character) 
+     - a range of any of the above, separated by a dash (C{'a-z'}, etc.) 
+     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.) 
+    """ 
+    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1)) 
+    try: 
+        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body) 
+    except Exception: 
+        return "" 
+ 
+def matchOnlyAtCol(n): 
+    """ 
+    Helper method for defining parse actions that require matching at a specific 
+    column in the input text. 
+    """ 
+    def verifyCol(strg,locn,toks): 
+        if col(locn,strg) != n: 
+            raise ParseException(strg,locn,"matched token not at column %d" % n) 
+    return verifyCol 
+ 
+def replaceWith(replStr): 
+    """ 
+    Helper method for common parse actions that simply return a literal value.  Especially 
+    useful when used with C{L{transformString<ParserElement.transformString>}()}. 
+ 
+    Example:: 
+        num = Word(nums).setParseAction(lambda toks: int(toks[0])) 
+        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan)) 
+        term = na | num 
+         
+        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234] 
+    """ 
+    return lambda s,l,t: [replStr] 
+ 
+def removeQuotes(s,l,t): 
+    """ 
+    Helper parse action for removing quotation marks from parsed quoted strings. 
+ 
+    Example:: 
+        # by default, quotation marks are included in parsed results 
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"] 
+ 
+        # use removeQuotes to strip quotation marks from parsed results 
+        quotedString.setParseAction(removeQuotes) 
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"] 
+    """ 
+    return t[0][1:-1] 
+ 
+def tokenMap(func, *args): 
+    """ 
+    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional  
+    args are passed, they are forwarded to the given function as additional arguments after 
+    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the 
+    parsed data to an integer using base 16. 
+ 
+    Example (compare the last to example in L{ParserElement.transformString}:: 
+        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16)) 
+        hex_ints.runTests(''' 
+            00 11 22 aa FF 0a 0d 1a 
+            ''') 
+         
+        upperword = Word(alphas).setParseAction(tokenMap(str.upper)) 
+        OneOrMore(upperword).runTests(''' 
+            my kingdom for a horse 
+            ''') 
+ 
+        wd = Word(alphas).setParseAction(tokenMap(str.title)) 
+        OneOrMore(wd).setParseAction(' '.join).runTests(''' 
+            now is the winter of our discontent made glorious summer by this sun of york 
+            ''') 
+    prints:: 
+        00 11 22 aa FF 0a 0d 1a 
+        [0, 17, 34, 170, 255, 10, 13, 26] 
+ 
+        my kingdom for a horse 
+        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE'] 
+ 
+        now is the winter of our discontent made glorious summer by this sun of york 
+        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York'] 
+    """ 
+    def pa(s,l,t): 
+        return [func(tokn, *args) for tokn in t] 
+ 
+    try: 
+        func_name = getattr(func, '__name__',  
+                            getattr(func, '__class__').__name__) 
+    except Exception: 
+        func_name = str(func) 
+    pa.__name__ = func_name 
+ 
+    return pa 
+ 
+upcaseTokens = tokenMap(lambda t: _ustr(t).upper()) 
+"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}""" 
+ 
+downcaseTokens = tokenMap(lambda t: _ustr(t).lower()) 
+"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}""" 
+     
+def _makeTags(tagStr, xml): 
+    """Internal helper to construct opening and closing tag expressions, given a tag name""" 
+    if isinstance(tagStr,basestring): 
+        resname = tagStr 
+        tagStr = Keyword(tagStr, caseless=not xml) 
+    else: 
+        resname = tagStr.name 
+ 
+    tagAttrName = Word(alphas,alphanums+"_-:") 
+    if (xml): 
+        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes ) 
+        openTag = Suppress("<") + tagStr("tag") + \ 
+                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \ 
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">") 
+    else: 
+        printablesLessRAbrack = "".join(c for c in printables if c not in ">") 
+        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack) 
+        openTag = Suppress("<") + tagStr("tag") + \ 
+                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \ 
+                Optional( Suppress("=") + tagAttrValue ) ))) + \ 
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">") 
+    closeTag = Combine(_L("</") + tagStr + ">") 
+ 
+    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname) 
+    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname) 
+    openTag.tag = resname 
+    closeTag.tag = resname 
+    return openTag, closeTag 
+ 
+def makeHTMLTags(tagStr): 
+    """ 
+    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches 
+    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values. 
+ 
+    Example:: 
+        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>' 
+        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple 
+        a,a_end = makeHTMLTags("A") 
+        link_expr = a + SkipTo(a_end)("link_text") + a_end 
+         
+        for link in link_expr.searchString(text): 
+            # attributes in the <A> tag (like "href" shown here) are also accessible as named results 
+            print(link.link_text, '->', link.href) 
+    prints:: 
+        pyparsing -> http://pyparsing.wikispaces.com 
+    """ 
+    return _makeTags( tagStr, False ) 
+ 
+def makeXMLTags(tagStr): 
+    """ 
+    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches 
+    tags only in the given upper/lower case. 
+ 
+    Example: similar to L{makeHTMLTags} 
+    """ 
+    return _makeTags( tagStr, True ) 
+ 
+def withAttribute(*args,**attrDict): 
+    """ 
+    Helper to create a validating parse action to be used with start tags created 
+    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag 
+    with a required attribute value, to avoid false matches on common tags such as 
+    C{<TD>} or C{<DIV>}. 
+ 
+    Call C{withAttribute} with a series of attribute names and values. Specify the list 
+    of filter attributes names and values as: 
+     - keyword arguments, as in C{(align="right")}, or 
+     - as an explicit dict with C{**} operator, when an attribute name is also a Python 
+          reserved word, as in C{**{"class":"Customer", "align":"right"}} 
+     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") ) 
+    For attribute names with a namespace prefix, you must use the second form.  Attribute 
+    names are matched insensitive to upper/lower case. 
+        
+    If just testing for C{class} (with or without a namespace), use C{L{withClass}}. 
+ 
+    To verify that the attribute exists, but without specifying a value, pass 
+    C{withAttribute.ANY_VALUE} as the value. 
+ 
+    Example:: 
+        html = ''' 
+            <div> 
+            Some text 
+            <div type="grid">1 4 0 1 0</div> 
+            <div type="graph">1,3 2,3 1,1</div> 
+            <div>this has no type</div> 
+            </div> 
+                 
+        ''' 
+        div,div_end = makeHTMLTags("div") 
+ 
+        # only match div tag having a type attribute with value "grid" 
+        div_grid = div().setParseAction(withAttribute(type="grid")) 
+        grid_expr = div_grid + SkipTo(div | div_end)("body") 
+        for grid_header in grid_expr.searchString(html): 
+            print(grid_header.body) 
+         
+        # construct a match with any div tag having a type attribute, regardless of the value 
+        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE)) 
+        div_expr = div_any_type + SkipTo(div | div_end)("body") 
+        for div_header in div_expr.searchString(html): 
+            print(div_header.body) 
+    prints:: 
+        1 4 0 1 0 
+ 
+        1 4 0 1 0 
+        1,3 2,3 1,1 
+    """ 
+    if args: 
+        attrs = args[:] 
+    else: 
+        attrs = attrDict.items() 
+    attrs = [(k,v) for k,v in attrs] 
+    def pa(s,l,tokens): 
+        for attrName,attrValue in attrs: 
+            if attrName not in tokens: 
+                raise ParseException(s,l,"no matching attribute " + attrName) 
+            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue: 
+                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" % 
+                                            (attrName, tokens[attrName], attrValue)) 
+    return pa 
+withAttribute.ANY_VALUE = object() 
+ 
+def withClass(classname, namespace=''): 
+    """ 
+    Simplified version of C{L{withAttribute}} when matching on a div class - made 
+    difficult because C{class} is a reserved word in Python. 
+ 
+    Example:: 
+        html = ''' 
+            <div> 
+            Some text 
+            <div class="grid">1 4 0 1 0</div> 
+            <div class="graph">1,3 2,3 1,1</div> 
+            <div>this &lt;div&gt; has no class</div> 
+            </div> 
+                 
+        ''' 
+        div,div_end = makeHTMLTags("div") 
+        div_grid = div().setParseAction(withClass("grid")) 
+         
+        grid_expr = div_grid + SkipTo(div | div_end)("body") 
+        for grid_header in grid_expr.searchString(html): 
+            print(grid_header.body) 
+         
+        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE)) 
+        div_expr = div_any_type + SkipTo(div | div_end)("body") 
+        for div_header in div_expr.searchString(html): 
+            print(div_header.body) 
+    prints:: 
+        1 4 0 1 0 
+ 
+        1 4 0 1 0 
+        1,3 2,3 1,1 
+    """ 
+    classattr = "%s:class" % namespace if namespace else "class" 
+    return withAttribute(**{classattr : classname})         
+ 
+opAssoc = _Constants() 
+opAssoc.LEFT = object() 
+opAssoc.RIGHT = object() 
+ 
+def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ): 
+    """ 
+    Helper method for constructing grammars of expressions made up of 
+    operators working in a precedence hierarchy.  Operators may be unary or 
+    binary, left- or right-associative.  Parse actions can also be attached 
+    to operator expressions. The generated parser will also recognize the use  
+    of parentheses to override operator precedences (see example below). 
+     
+    Note: if you define a deep operator list, you may see performance issues 
+    when using infixNotation. See L{ParserElement.enablePackrat} for a 
+    mechanism to potentially improve your parser performance. 
+ 
+    Parameters: 
+     - baseExpr - expression representing the most basic element for the nested 
+     - opList - list of tuples, one for each operator precedence level in the 
+      expression grammar; each tuple is of the form 
+      (opExpr, numTerms, rightLeftAssoc, parseAction), where: 
+       - opExpr is the pyparsing expression for the operator; 
+          may also be a string, which will be converted to a Literal; 
+          if numTerms is 3, opExpr is a tuple of two expressions, for the 
+          two operators separating the 3 terms 
+       - numTerms is the number of terms for this operator (must 
+          be 1, 2, or 3) 
+       - rightLeftAssoc is the indicator whether the operator is 
+          right or left associative, using the pyparsing-defined 
+          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}. 
+       - parseAction is the parse action to be associated with 
+          expressions matching this operator expression (the 
+          parse action tuple member may be omitted); if the parse action 
+          is passed a tuple or list of functions, this is equivalent to 
+          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction}) 
+     - lpar - expression for matching left-parentheses (default=C{Suppress('(')}) 
+     - rpar - expression for matching right-parentheses (default=C{Suppress(')')}) 
+ 
+    Example:: 
+        # simple example of four-function arithmetic with ints and variable names 
+        integer = pyparsing_common.signed_integer 
+        varname = pyparsing_common.identifier  
+         
+        arith_expr = infixNotation(integer | varname, 
+            [ 
+            ('-', 1, opAssoc.RIGHT), 
+            (oneOf('* /'), 2, opAssoc.LEFT), 
+            (oneOf('+ -'), 2, opAssoc.LEFT), 
+            ]) 
+         
+        arith_expr.runTests(''' 
+            5+3*6 
+            (5+3)*6 
+            -2--11 
+            ''', fullDump=False) 
+    prints:: 
+        5+3*6 
+        [[5, '+', [3, '*', 6]]] 
+ 
+        (5+3)*6 
+        [[[5, '+', 3], '*', 6]] 
+ 
+        -2--11 
+        [[['-', 2], '-', ['-', 11]]] 
+    """ 
+    ret = Forward() 
+    lastExpr = baseExpr | ( lpar + ret + rpar ) 
+    for i,operDef in enumerate(opList): 
+        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4] 
+        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr 
+        if arity == 3: 
+            if opExpr is None or len(opExpr) != 2: 
+                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions") 
+            opExpr1, opExpr2 = opExpr 
+        thisExpr = Forward().setName(termName) 
+        if rightLeftAssoc == opAssoc.LEFT: 
+            if arity == 1: 
+                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) ) 
+            elif arity == 2: 
+                if opExpr is not None: 
+                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) ) 
+                else: 
+                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) ) 
+            elif arity == 3: 
+                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \ 
+                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr ) 
+            else: 
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)") 
+        elif rightLeftAssoc == opAssoc.RIGHT: 
+            if arity == 1: 
+                # try to avoid LR with this extra test 
+                if not isinstance(opExpr, Optional): 
+                    opExpr = Optional(opExpr) 
+                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr ) 
+            elif arity == 2: 
+                if opExpr is not None: 
+                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) ) 
+                else: 
+                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) ) 
+            elif arity == 3: 
+                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \ 
+                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr ) 
+            else: 
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)") 
+        else: 
+            raise ValueError("operator must indicate right or left associativity") 
+        if pa: 
+            if isinstance(pa, (tuple, list)): 
+                matchExpr.setParseAction(*pa) 
+            else: 
+                matchExpr.setParseAction(pa) 
+        thisExpr <<= ( matchExpr.setName(termName) | lastExpr ) 
+        lastExpr = thisExpr 
+    ret <<= lastExpr 
+    return ret 
+ 
+operatorPrecedence = infixNotation 
+"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release.""" 
+ 
+dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes") 
+sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes") 
+quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'| 
+                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes") 
+unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal") 
+ 
+def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()): 
+    """ 
+    Helper method for defining nested lists enclosed in opening and closing 
+    delimiters ("(" and ")" are the default). 
+ 
+    Parameters: 
+     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression 
+     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression 
+     - content - expression for items within the nested lists (default=C{None}) 
+     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString}) 
+ 
+    If an expression is not provided for the content argument, the nested 
+    expression will capture all whitespace-delimited content between delimiters 
+    as a list of separate values. 
+ 
+    Use the C{ignoreExpr} argument to define expressions that may contain 
+    opening or closing characters that should not be treated as opening 
+    or closing characters for nesting, such as quotedString or a comment 
+    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}. 
+    The default is L{quotedString}, but if no expressions are to be ignored, 
+    then pass C{None} for this argument. 
+ 
+    Example:: 
+        data_type = oneOf("void int short long char float double") 
+        decl_data_type = Combine(data_type + Optional(Word('*'))) 
+        ident = Word(alphas+'_', alphanums+'_') 
+        number = pyparsing_common.number 
+        arg = Group(decl_data_type + ident) 
+        LPAR,RPAR = map(Suppress, "()") 
+ 
+        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment)) 
+ 
+        c_function = (decl_data_type("type")  
+                      + ident("name") 
+                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR  
+                      + code_body("body")) 
+        c_function.ignore(cStyleComment) 
+         
+        source_code = ''' 
+            int is_odd(int x) {  
+                return (x%2);  
+            } 
+                 
+            int dec_to_hex(char hchar) {  
+                if (hchar >= '0' && hchar <= '9') {  
+                    return (ord(hchar)-ord('0'));  
+                } else {  
+                    return (10+ord(hchar)-ord('A')); 
+                }  
+            } 
+        ''' 
+        for func in c_function.searchString(source_code): 
+            print("%(name)s (%(type)s) args: %(args)s" % func) 
+ 
+    prints:: 
+        is_odd (int) args: [['int', 'x']] 
+        dec_to_hex (int) args: [['char', 'hchar']] 
+    """ 
+    if opener == closer: 
+        raise ValueError("opening and closing strings cannot be the same") 
+    if content is None: 
+        if isinstance(opener,basestring) and isinstance(closer,basestring): 
+            if len(opener) == 1 and len(closer)==1: 
+                if ignoreExpr is not None: 
+                    content = (Combine(OneOrMore(~ignoreExpr + 
+                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1)) 
+                                ).setParseAction(lambda t:t[0].strip())) 
+                else: 
+                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS 
+                                ).setParseAction(lambda t:t[0].strip())) 
+            else: 
+                if ignoreExpr is not None: 
+                    content = (Combine(OneOrMore(~ignoreExpr +  
+                                    ~Literal(opener) + ~Literal(closer) + 
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1)) 
+                                ).setParseAction(lambda t:t[0].strip())) 
+                else: 
+                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) + 
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1)) 
+                                ).setParseAction(lambda t:t[0].strip())) 
+        else: 
+            raise ValueError("opening and closing arguments must be strings if no content expression is given") 
+    ret = Forward() 
+    if ignoreExpr is not None: 
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) ) 
+    else: 
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) ) 
+    ret.setName('nested %s%s expression' % (opener,closer)) 
+    return ret 
+ 
+def indentedBlock(blockStatementExpr, indentStack, indent=True): 
+    """ 
+    Helper method for defining space-delimited indentation blocks, such as 
+    those used to define block statements in Python source code. 
+ 
+    Parameters: 
+     - blockStatementExpr - expression defining syntax of statement that 
+            is repeated within the indented block 
+     - indentStack - list created by caller to manage indentation stack 
+            (multiple statementWithIndentedBlock expressions within a single grammar 
+            should share a common indentStack) 
+     - indent - boolean indicating whether block must be indented beyond the 
+            the current level; set to False for block of left-most statements 
+            (default=C{True}) 
+ 
+    A valid block must contain at least one C{blockStatement}. 
+ 
+    Example:: 
+        data = ''' 
+        def A(z): 
+          A1 
+          B = 100 
+          G = A2 
+          A2 
+          A3 
+        B 
+        def BB(a,b,c): 
+          BB1 
+          def BBA(): 
+            bba1 
+            bba2 
+            bba3 
+        C 
+        D 
+        def spam(x,y): 
+             def eggs(z): 
+                 pass 
+        ''' 
+ 
+ 
+        indentStack = [1] 
+        stmt = Forward() 
+ 
+        identifier = Word(alphas, alphanums) 
+        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":") 
+        func_body = indentedBlock(stmt, indentStack) 
+        funcDef = Group( funcDecl + func_body ) 
+ 
+        rvalue = Forward() 
+        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")") 
+        rvalue << (funcCall | identifier | Word(nums)) 
+        assignment = Group(identifier + "=" + rvalue) 
+        stmt << ( funcDef | assignment | identifier ) 
+ 
+        module_body = OneOrMore(stmt) 
+ 
+        parseTree = module_body.parseString(data) 
+        parseTree.pprint() 
+    prints:: 
+        [['def', 
+          'A', 
+          ['(', 'z', ')'], 
+          ':', 
+          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]], 
+         'B', 
+         ['def', 
+          'BB', 
+          ['(', 'a', 'b', 'c', ')'], 
+          ':', 
+          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]], 
+         'C', 
+         'D', 
+         ['def', 
+          'spam', 
+          ['(', 'x', 'y', ')'], 
+          ':', 
+          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]]  
+    """ 
+    def checkPeerIndent(s,l,t): 
+        if l >= len(s): return 
+        curCol = col(l,s) 
+        if curCol != indentStack[-1]: 
+            if curCol > indentStack[-1]: 
+                raise ParseFatalException(s,l,"illegal nesting") 
+            raise ParseException(s,l,"not a peer entry") 
+ 
+    def checkSubIndent(s,l,t): 
+        curCol = col(l,s) 
+        if curCol > indentStack[-1]: 
+            indentStack.append( curCol ) 
+        else: 
+            raise ParseException(s,l,"not a subentry") 
+ 
+    def checkUnindent(s,l,t): 
+        if l >= len(s): return 
+        curCol = col(l,s) 
+        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]): 
+            raise ParseException(s,l,"not an unindent") 
+        indentStack.pop() 
+ 
+    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress()) 
+    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT') 
+    PEER   = Empty().setParseAction(checkPeerIndent).setName('') 
+    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT') 
+    if indent: 
+        smExpr = Group( Optional(NL) + 
+            #~ FollowedBy(blockStatementExpr) + 
+            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT) 
+    else: 
+        smExpr = Group( Optional(NL) + 
+            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) ) 
+    blockStatementExpr.ignore(_bslash + LineEnd()) 
+    return smExpr.setName('indented block') 
+ 
+alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]") 
+punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]") 
+ 
+anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag')) 
+_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\'')) 
+commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity") 
+def replaceHTMLEntity(t): 
+    """Helper parser action to replace common HTML entities with their special characters""" 
+    return _htmlEntityMap.get(t.entity) 
+ 
+# it's easy to get these comment structures wrong - they're very common, so may as well make them available 
+cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment") 
+"Comment of the form C{/* ... */}" 
+ 
+htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment") 
+"Comment of the form C{<!-- ... -->}" 
+ 
+restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line") 
+dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment") 
+"Comment of the form C{// ... (to end of line)}" 
+ 
+cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment") 
+"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}" 
+ 
+javaStyleComment = cppStyleComment 
+"Same as C{L{cppStyleComment}}" 
+ 
+pythonStyleComment = Regex(r"#.*").setName("Python style comment") 
+"Comment of the form C{# ... (to end of line)}" 
+ 
+_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') + 
+                                  Optional( Word(" \t") + 
+                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem") 
+commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList") 
+"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas. 
+   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}.""" 
+ 
+# some other useful expressions - using lower-case class name since we are really using this as a namespace 
+class pyparsing_common: 
+    """ 
+    Here are some common low-level expressions that may be useful in jump-starting parser development: 
+     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>}) 
+     - common L{programming identifiers<identifier>} 
+     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>}) 
+     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>} 
+     - L{UUID<uuid>} 
+     - L{comma-separated list<comma_separated_list>} 
+    Parse actions: 
+     - C{L{convertToInteger}} 
+     - C{L{convertToFloat}} 
+     - C{L{convertToDate}} 
+     - C{L{convertToDatetime}} 
+     - C{L{stripHTMLTags}} 
+     - C{L{upcaseTokens}} 
+     - C{L{downcaseTokens}} 
+ 
+    Example:: 
+        pyparsing_common.number.runTests(''' 
+            # any int or real number, returned as the appropriate type 
+            100 
+            -100 
+            +100 
+            3.14159 
+            6.02e23 
+            1e-12 
+            ''') 
+ 
+        pyparsing_common.fnumber.runTests(''' 
+            # any int or real number, returned as float 
+            100 
+            -100 
+            +100 
+            3.14159 
+            6.02e23 
+            1e-12 
+            ''') 
+ 
+        pyparsing_common.hex_integer.runTests(''' 
+            # hex numbers 
+            100 
+            FF 
+            ''') 
+ 
+        pyparsing_common.fraction.runTests(''' 
+            # fractions 
+            1/2 
+            -3/4 
+            ''') 
+ 
+        pyparsing_common.mixed_integer.runTests(''' 
+            # mixed fractions 
+            1 
+            1/2 
+            -3/4 
+            1-3/4 
+            ''') 
+ 
+        import uuid 
+        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID)) 
+        pyparsing_common.uuid.runTests(''' 
+            # uuid 
+            12345678-1234-5678-1234-567812345678 
+            ''') 
+    prints:: 
+        # any int or real number, returned as the appropriate type 
+        100 
+        [100] 
+ 
+        -100 
+        [-100] 
+ 
+        +100 
+        [100] 
+ 
+        3.14159 
+        [3.14159] 
+ 
+        6.02e23 
+        [6.02e+23] 
+ 
+        1e-12 
+        [1e-12] 
+ 
+        # any int or real number, returned as float 
+        100 
+        [100.0] 
+ 
+        -100 
+        [-100.0] 
+ 
+        +100 
+        [100.0] 
+ 
+        3.14159 
+        [3.14159] 
+ 
+        6.02e23 
+        [6.02e+23] 
+ 
+        1e-12 
+        [1e-12] 
+ 
+        # hex numbers 
+        100 
+        [256] 
+ 
+        FF 
+        [255] 
+ 
+        # fractions 
+        1/2 
+        [0.5] 
+ 
+        -3/4 
+        [-0.75] 
+ 
+        # mixed fractions 
+        1 
+        [1] 
+ 
+        1/2 
+        [0.5] 
+ 
+        -3/4 
+        [-0.75] 
+ 
+        1-3/4 
+        [1.75] 
+ 
+        # uuid 
+        12345678-1234-5678-1234-567812345678 
+        [UUID('12345678-1234-5678-1234-567812345678')] 
+    """ 
+ 
+    convertToInteger = tokenMap(int) 
+    """ 
+    Parse action for converting parsed integers to Python int 
+    """ 
+ 
+    convertToFloat = tokenMap(float) 
+    """ 
+    Parse action for converting parsed numbers to Python float 
+    """ 
+ 
+    integer = Word(nums).setName("integer").setParseAction(convertToInteger) 
+    """expression that parses an unsigned integer, returns an int""" 
+ 
+    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16)) 
+    """expression that parses a hexadecimal integer, returns an int""" 
+ 
+    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger) 
+    """expression that parses an integer with optional leading sign, returns an int""" 
+ 
+    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction") 
+    """fractional expression of an integer divided by an integer, returns a float""" 
+    fraction.addParseAction(lambda t: t[0]/t[-1]) 
+ 
+    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction") 
+    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float""" 
+    mixed_integer.addParseAction(sum) 
+ 
+    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat) 
+    """expression that parses a floating point number and returns a float""" 
+ 
+    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat) 
+    """expression that parses a floating point number with optional scientific notation and returns a float""" 
+ 
+    # streamlining this expression makes the docs nicer-looking 
+    number = (sci_real | real | signed_integer).streamline() 
+    """any numeric expression, returns the corresponding Python type""" 
+ 
+    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat) 
+    """any int or real number, returned as float""" 
+     
+    identifier = Word(alphas+'_', alphanums+'_').setName("identifier") 
+    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')""" 
+     
+    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address") 
+    "IPv4 address (C{0.0.0.0 - 255.255.255.255})" 
+ 
+    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer") 
+    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address") 
+    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address") 
+    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8) 
+    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address") 
+    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address") 
+    "IPv6 address (long, short, or mixed form)" 
+     
+    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address") 
+    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)" 
+ 
+    @staticmethod 
+    def convertToDate(fmt="%Y-%m-%d"): 
+        """ 
+        Helper to create a parse action for converting parsed date string to Python datetime.date 
+ 
+        Params - 
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"}) 
+ 
+        Example:: 
+            date_expr = pyparsing_common.iso8601_date.copy() 
+            date_expr.setParseAction(pyparsing_common.convertToDate()) 
+            print(date_expr.parseString("1999-12-31")) 
+        prints:: 
+            [datetime.date(1999, 12, 31)] 
+        """ 
+        def cvt_fn(s,l,t): 
+            try: 
+                return datetime.strptime(t[0], fmt).date() 
+            except ValueError as ve: 
+                raise ParseException(s, l, str(ve)) 
+        return cvt_fn 
+ 
+    @staticmethod 
+    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"): 
+        """ 
+        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime 
+ 
+        Params - 
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"}) 
+ 
+        Example:: 
+            dt_expr = pyparsing_common.iso8601_datetime.copy() 
+            dt_expr.setParseAction(pyparsing_common.convertToDatetime()) 
+            print(dt_expr.parseString("1999-12-31T23:59:59.999")) 
+        prints:: 
+            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)] 
+        """ 
+        def cvt_fn(s,l,t): 
+            try: 
+                return datetime.strptime(t[0], fmt) 
+            except ValueError as ve: 
+                raise ParseException(s, l, str(ve)) 
+        return cvt_fn 
+ 
+    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date") 
+    "ISO8601 date (C{yyyy-mm-dd})" 
+ 
+    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime") 
+    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}" 
+ 
+    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID") 
+    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})" 
+ 
+    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress() 
+    @staticmethod 
+    def stripHTMLTags(s, l, tokens): 
+        """ 
+        Parse action to remove HTML tags from web page HTML source 
+ 
+        Example:: 
+            # strip HTML links from normal text  
+            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>' 
+            td,td_end = makeHTMLTags("TD") 
+            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end 
+             
+            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page' 
+        """ 
+        return pyparsing_common._html_stripper.transformString(tokens[0]) 
+ 
+    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',')  
+                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem") 
+    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list") 
+    """Predefined expression of 1 or more printable words or quoted strings, separated by commas.""" 
+ 
+    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper())) 
+    """Parse action to convert tokens to upper case.""" 
+ 
+    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower())) 
+    """Parse action to convert tokens to lower case.""" 
+ 
+ 
+if __name__ == "__main__": 
+ 
+    selectToken    = CaselessLiteral("select") 
+    fromToken      = CaselessLiteral("from") 
+ 
+    ident          = Word(alphas, alphanums + "_$") 
+ 
+    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens) 
+    columnNameList = Group(delimitedList(columnName)).setName("columns") 
+    columnSpec     = ('*' | columnNameList) 
+ 
+    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens) 
+    tableNameList  = Group(delimitedList(tableName)).setName("tables") 
+     
+    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables") 
+ 
+    # demo runTests method, including embedded comments in test string 
+    simpleSQL.runTests(""" 
+        # '*' as column list and dotted table name 
+        select * from SYS.XYZZY 
+ 
+        # caseless match on "SELECT", and casts back to "select" 
+        SELECT * from XYZZY, ABC 
+ 
+        # list of column names, and mixed case SELECT keyword 
+        Select AA,BB,CC from Sys.dual 
+ 
+        # multiple tables 
+        Select A, B, C from Sys.dual, Table2 
+ 
+        # invalid SELECT keyword - should fail 
+        Xelect A, B, C from Sys.dual 
+ 
+        # incomplete command - should fail 
+        Select 
+ 
+        # invalid column name - should fail 
+        Select ^^^ frox Sys.dual 
+ 
+        """) 
+ 
+    pyparsing_common.number.runTests(""" 
+        100 
+        -100 
+        +100 
+        3.14159 
+        6.02e23 
+        1e-12 
+        """) 
+ 
+    # any int or real number, returned as float 
+    pyparsing_common.fnumber.runTests(""" 
+        100 
+        -100 
+        +100 
+        3.14159 
+        6.02e23 
+        1e-12 
+        """) 
+ 
+    pyparsing_common.hex_integer.runTests(""" 
+        100 
+        FF 
+        """) 
+ 
+    import uuid 
+    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID)) 
+    pyparsing_common.uuid.runTests(""" 
+        12345678-1234-5678-1234-567812345678 
+        """) 
diff --git a/contrib/python/setuptools/py2/setuptools/_vendor/six.py b/contrib/python/setuptools/py2/setuptools/_vendor/six.py
index 190c0239cd..2d8569e762 100644
--- a/contrib/python/setuptools/py2/setuptools/_vendor/six.py
+++ b/contrib/python/setuptools/py2/setuptools/_vendor/six.py
@@ -1,868 +1,868 @@
-"""Utilities for writing code that runs on Python 2 and 3"""
-
-# Copyright (c) 2010-2015 Benjamin Peterson
-#
-# 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 __future__ import absolute_import
-
-import functools
-import itertools
-import operator
-import sys
-import types
-
-__author__ = "Benjamin Peterson <benjamin@python.org>"
-__version__ = "1.10.0"
-
-
-# Useful for very coarse version differentiation.
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-PY34 = sys.version_info[0:2] >= (3, 4)
-
-if PY3:
-    string_types = str,
-    integer_types = int,
-    class_types = type,
-    text_type = str
-    binary_type = bytes
-
-    MAXSIZE = sys.maxsize
-else:
-    string_types = basestring,
-    integer_types = (int, long)
-    class_types = (type, types.ClassType)
-    text_type = unicode
-    binary_type = str
-
-    if sys.platform.startswith("java"):
-        # Jython always uses 32 bits.
-        MAXSIZE = int((1 << 31) - 1)
-    else:
-        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
-        class X(object):
-
-            def __len__(self):
-                return 1 << 31
-        try:
-            len(X())
-        except OverflowError:
-            # 32-bit
-            MAXSIZE = int((1 << 31) - 1)
-        else:
-            # 64-bit
-            MAXSIZE = int((1 << 63) - 1)
-        del X
-
-
-def _add_doc(func, doc):
-    """Add documentation to a function."""
-    func.__doc__ = doc
-
-
-def _import_module(name):
-    """Import module, returning the module after the last dot."""
-    __import__(name)
-    return sys.modules[name]
-
-
-class _LazyDescr(object):
-
-    def __init__(self, name):
-        self.name = name
-
-    def __get__(self, obj, tp):
-        result = self._resolve()
-        setattr(obj, self.name, result)  # Invokes __set__.
-        try:
-            # This is a bit ugly, but it avoids running this again by
-            # removing this descriptor.
-            delattr(obj.__class__, self.name)
-        except AttributeError:
-            pass
-        return result
-
-
-class MovedModule(_LazyDescr):
-
-    def __init__(self, name, old, new=None):
-        super(MovedModule, self).__init__(name)
-        if PY3:
-            if new is None:
-                new = name
-            self.mod = new
-        else:
-            self.mod = old
-
-    def _resolve(self):
-        return _import_module(self.mod)
-
-    def __getattr__(self, attr):
-        _module = self._resolve()
-        value = getattr(_module, attr)
-        setattr(self, attr, value)
-        return value
-
-
-class _LazyModule(types.ModuleType):
-
-    def __init__(self, name):
-        super(_LazyModule, self).__init__(name)
-        self.__doc__ = self.__class__.__doc__
-
-    def __dir__(self):
-        attrs = ["__doc__", "__name__"]
-        attrs += [attr.name for attr in self._moved_attributes]
-        return attrs
-
-    # Subclasses should override this
-    _moved_attributes = []
-
-
-class MovedAttribute(_LazyDescr):
-
-    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
-        super(MovedAttribute, self).__init__(name)
-        if PY3:
-            if new_mod is None:
-                new_mod = name
-            self.mod = new_mod
-            if new_attr is None:
-                if old_attr is None:
-                    new_attr = name
-                else:
-                    new_attr = old_attr
-            self.attr = new_attr
-        else:
-            self.mod = old_mod
-            if old_attr is None:
-                old_attr = name
-            self.attr = old_attr
-
-    def _resolve(self):
-        module = _import_module(self.mod)
-        return getattr(module, self.attr)
-
-
-class _SixMetaPathImporter(object):
-
-    """
-    A meta path importer to import six.moves and its submodules.
-
-    This class implements a PEP302 finder and loader. It should be compatible
-    with Python 2.5 and all existing versions of Python3
-    """
-
-    def __init__(self, six_module_name):
-        self.name = six_module_name
-        self.known_modules = {}
-
-    def _add_module(self, mod, *fullnames):
-        for fullname in fullnames:
-            self.known_modules[self.name + "." + fullname] = mod
-
-    def _get_module(self, fullname):
-        return self.known_modules[self.name + "." + fullname]
-
-    def find_module(self, fullname, path=None):
-        if fullname in self.known_modules:
-            return self
-        return None
-
-    def __get_module(self, fullname):
-        try:
-            return self.known_modules[fullname]
-        except KeyError:
-            raise ImportError("This loader does not know module " + fullname)
-
-    def load_module(self, fullname):
-        try:
-            # in case of a reload
-            return sys.modules[fullname]
-        except KeyError:
-            pass
-        mod = self.__get_module(fullname)
-        if isinstance(mod, MovedModule):
-            mod = mod._resolve()
-        else:
-            mod.__loader__ = self
-        sys.modules[fullname] = mod
-        return mod
-
-    def is_package(self, fullname):
-        """
-        Return true, if the named module is a package.
-
-        We need this method to get correct spec objects with
-        Python 3.4 (see PEP451)
-        """
-        return hasattr(self.__get_module(fullname), "__path__")
-
-    def get_code(self, fullname):
-        """Return None
-
-        Required, if is_package is implemented"""
-        self.__get_module(fullname)  # eventually raises ImportError
-        return None
-    get_source = get_code  # same as get_code
-
-_importer = _SixMetaPathImporter(__name__)
-
-
-class _MovedItems(_LazyModule):
-
-    """Lazy loading of moved objects"""
-    __path__ = []  # mark as package
-
-
-_moved_attributes = [
-    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
-    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
-    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
-    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
-    MovedAttribute("intern", "__builtin__", "sys"),
-    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
-    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
-    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
-    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
-    MovedAttribute("reduce", "__builtin__", "functools"),
-    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
-    MovedAttribute("StringIO", "StringIO", "io"),
-    MovedAttribute("UserDict", "UserDict", "collections"),
-    MovedAttribute("UserList", "UserList", "collections"),
-    MovedAttribute("UserString", "UserString", "collections"),
-    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
-    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
-    MovedModule("builtins", "__builtin__"),
-    MovedModule("configparser", "ConfigParser"),
-    MovedModule("copyreg", "copy_reg"),
-    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
-    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
-    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
-    MovedModule("http_cookies", "Cookie", "http.cookies"),
-    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
-    MovedModule("html_parser", "HTMLParser", "html.parser"),
-    MovedModule("http_client", "httplib", "http.client"),
-    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
-    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
-    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
-    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
-    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
-    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
-    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
-    MovedModule("cPickle", "cPickle", "pickle"),
-    MovedModule("queue", "Queue"),
-    MovedModule("reprlib", "repr"),
-    MovedModule("socketserver", "SocketServer"),
-    MovedModule("_thread", "thread", "_thread"),
-    MovedModule("tkinter", "Tkinter"),
-    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
-    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
-    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
-    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
-    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
-    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
-    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
-    MovedModule("tkinter_colorchooser", "tkColorChooser",
-                "tkinter.colorchooser"),
-    MovedModule("tkinter_commondialog", "tkCommonDialog",
-                "tkinter.commondialog"),
-    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
-    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
-    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
-                "tkinter.simpledialog"),
-    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
-    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
-    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
-    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
-    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
-    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
-]
-# Add windows specific modules.
-if sys.platform == "win32":
-    _moved_attributes += [
-        MovedModule("winreg", "_winreg"),
-    ]
-
-for attr in _moved_attributes:
-    setattr(_MovedItems, attr.name, attr)
-    if isinstance(attr, MovedModule):
-        _importer._add_module(attr, "moves." + attr.name)
-del attr
-
-_MovedItems._moved_attributes = _moved_attributes
-
-moves = _MovedItems(__name__ + ".moves")
-_importer._add_module(moves, "moves")
-
-
-class Module_six_moves_urllib_parse(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_parse"""
-
-
-_urllib_parse_moved_attributes = [
-    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
-    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
-    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
-    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
-    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("quote", "urllib", "urllib.parse"),
-    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("unquote", "urllib", "urllib.parse"),
-    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("urlencode", "urllib", "urllib.parse"),
-    MovedAttribute("splitquery", "urllib", "urllib.parse"),
-    MovedAttribute("splittag", "urllib", "urllib.parse"),
-    MovedAttribute("splituser", "urllib", "urllib.parse"),
-    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
-]
-for attr in _urllib_parse_moved_attributes:
-    setattr(Module_six_moves_urllib_parse, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
-                      "moves.urllib_parse", "moves.urllib.parse")
-
-
-class Module_six_moves_urllib_error(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_error"""
-
-
-_urllib_error_moved_attributes = [
-    MovedAttribute("URLError", "urllib2", "urllib.error"),
-    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
-    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
-]
-for attr in _urllib_error_moved_attributes:
-    setattr(Module_six_moves_urllib_error, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
-                      "moves.urllib_error", "moves.urllib.error")
-
-
-class Module_six_moves_urllib_request(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_request"""
-
-
-_urllib_request_moved_attributes = [
-    MovedAttribute("urlopen", "urllib2", "urllib.request"),
-    MovedAttribute("install_opener", "urllib2", "urllib.request"),
-    MovedAttribute("build_opener", "urllib2", "urllib.request"),
-    MovedAttribute("pathname2url", "urllib", "urllib.request"),
-    MovedAttribute("url2pathname", "urllib", "urllib.request"),
-    MovedAttribute("getproxies", "urllib", "urllib.request"),
-    MovedAttribute("Request", "urllib2", "urllib.request"),
-    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
-    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
-    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
-    MovedAttribute("URLopener", "urllib", "urllib.request"),
-    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
-    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
-]
-for attr in _urllib_request_moved_attributes:
-    setattr(Module_six_moves_urllib_request, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
-                      "moves.urllib_request", "moves.urllib.request")
-
-
-class Module_six_moves_urllib_response(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_response"""
-
-
-_urllib_response_moved_attributes = [
-    MovedAttribute("addbase", "urllib", "urllib.response"),
-    MovedAttribute("addclosehook", "urllib", "urllib.response"),
-    MovedAttribute("addinfo", "urllib", "urllib.response"),
-    MovedAttribute("addinfourl", "urllib", "urllib.response"),
-]
-for attr in _urllib_response_moved_attributes:
-    setattr(Module_six_moves_urllib_response, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
-                      "moves.urllib_response", "moves.urllib.response")
-
-
-class Module_six_moves_urllib_robotparser(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
-
-
-_urllib_robotparser_moved_attributes = [
-    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
-]
-for attr in _urllib_robotparser_moved_attributes:
-    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
-                      "moves.urllib_robotparser", "moves.urllib.robotparser")
-
-
-class Module_six_moves_urllib(types.ModuleType):
-
-    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
-    __path__ = []  # mark as package
-    parse = _importer._get_module("moves.urllib_parse")
-    error = _importer._get_module("moves.urllib_error")
-    request = _importer._get_module("moves.urllib_request")
-    response = _importer._get_module("moves.urllib_response")
-    robotparser = _importer._get_module("moves.urllib_robotparser")
-
-    def __dir__(self):
-        return ['parse', 'error', 'request', 'response', 'robotparser']
-
-_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
-                      "moves.urllib")
-
-
-def add_move(move):
-    """Add an item to six.moves."""
-    setattr(_MovedItems, move.name, move)
-
-
-def remove_move(name):
-    """Remove item from six.moves."""
-    try:
-        delattr(_MovedItems, name)
-    except AttributeError:
-        try:
-            del moves.__dict__[name]
-        except KeyError:
-            raise AttributeError("no such move, %r" % (name,))
-
-
-if PY3:
-    _meth_func = "__func__"
-    _meth_self = "__self__"
-
-    _func_closure = "__closure__"
-    _func_code = "__code__"
-    _func_defaults = "__defaults__"
-    _func_globals = "__globals__"
-else:
-    _meth_func = "im_func"
-    _meth_self = "im_self"
-
-    _func_closure = "func_closure"
-    _func_code = "func_code"
-    _func_defaults = "func_defaults"
-    _func_globals = "func_globals"
-
-
-try:
-    advance_iterator = next
-except NameError:
-    def advance_iterator(it):
-        return it.next()
-next = advance_iterator
-
-
-try:
-    callable = callable
-except NameError:
-    def callable(obj):
-        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
-
-
-if PY3:
-    def get_unbound_function(unbound):
-        return unbound
-
-    create_bound_method = types.MethodType
-
-    def create_unbound_method(func, cls):
-        return func
-
-    Iterator = object
-else:
-    def get_unbound_function(unbound):
-        return unbound.im_func
-
-    def create_bound_method(func, obj):
-        return types.MethodType(func, obj, obj.__class__)
-
-    def create_unbound_method(func, cls):
-        return types.MethodType(func, None, cls)
-
-    class Iterator(object):
-
-        def next(self):
-            return type(self).__next__(self)
-
-    callable = callable
-_add_doc(get_unbound_function,
-         """Get the function out of a possibly unbound function""")
-
-
-get_method_function = operator.attrgetter(_meth_func)
-get_method_self = operator.attrgetter(_meth_self)
-get_function_closure = operator.attrgetter(_func_closure)
-get_function_code = operator.attrgetter(_func_code)
-get_function_defaults = operator.attrgetter(_func_defaults)
-get_function_globals = operator.attrgetter(_func_globals)
-
-
-if PY3:
-    def iterkeys(d, **kw):
-        return iter(d.keys(**kw))
-
-    def itervalues(d, **kw):
-        return iter(d.values(**kw))
-
-    def iteritems(d, **kw):
-        return iter(d.items(**kw))
-
-    def iterlists(d, **kw):
-        return iter(d.lists(**kw))
-
-    viewkeys = operator.methodcaller("keys")
-
-    viewvalues = operator.methodcaller("values")
-
-    viewitems = operator.methodcaller("items")
-else:
-    def iterkeys(d, **kw):
-        return d.iterkeys(**kw)
-
-    def itervalues(d, **kw):
-        return d.itervalues(**kw)
-
-    def iteritems(d, **kw):
-        return d.iteritems(**kw)
-
-    def iterlists(d, **kw):
-        return d.iterlists(**kw)
-
-    viewkeys = operator.methodcaller("viewkeys")
-
-    viewvalues = operator.methodcaller("viewvalues")
-
-    viewitems = operator.methodcaller("viewitems")
-
-_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
-_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
-_add_doc(iteritems,
-         "Return an iterator over the (key, value) pairs of a dictionary.")
-_add_doc(iterlists,
-         "Return an iterator over the (key, [values]) pairs of a dictionary.")
-
-
-if PY3:
-    def b(s):
-        return s.encode("latin-1")
-
-    def u(s):
-        return s
-    unichr = chr
-    import struct
-    int2byte = struct.Struct(">B").pack
-    del struct
-    byte2int = operator.itemgetter(0)
-    indexbytes = operator.getitem
-    iterbytes = iter
-    import io
-    StringIO = io.StringIO
-    BytesIO = io.BytesIO
-    _assertCountEqual = "assertCountEqual"
-    if sys.version_info[1] <= 1:
-        _assertRaisesRegex = "assertRaisesRegexp"
-        _assertRegex = "assertRegexpMatches"
-    else:
-        _assertRaisesRegex = "assertRaisesRegex"
-        _assertRegex = "assertRegex"
-else:
-    def b(s):
-        return s
-    # Workaround for standalone backslash
-
-    def u(s):
-        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
-    unichr = unichr
-    int2byte = chr
-
-    def byte2int(bs):
-        return ord(bs[0])
-
-    def indexbytes(buf, i):
-        return ord(buf[i])
-    iterbytes = functools.partial(itertools.imap, ord)
-    import StringIO
-    StringIO = BytesIO = StringIO.StringIO
-    _assertCountEqual = "assertItemsEqual"
-    _assertRaisesRegex = "assertRaisesRegexp"
-    _assertRegex = "assertRegexpMatches"
-_add_doc(b, """Byte literal""")
-_add_doc(u, """Text literal""")
-
-
-def assertCountEqual(self, *args, **kwargs):
-    return getattr(self, _assertCountEqual)(*args, **kwargs)
-
-
-def assertRaisesRegex(self, *args, **kwargs):
-    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
-
-
-def assertRegex(self, *args, **kwargs):
-    return getattr(self, _assertRegex)(*args, **kwargs)
-
-
-if PY3:
-    exec_ = getattr(moves.builtins, "exec")
-
-    def reraise(tp, value, tb=None):
-        if value is None:
-            value = tp()
-        if value.__traceback__ is not tb:
-            raise value.with_traceback(tb)
-        raise value
-
-else:
-    def exec_(_code_, _globs_=None, _locs_=None):
-        """Execute code in a namespace."""
-        if _globs_ is None:
-            frame = sys._getframe(1)
-            _globs_ = frame.f_globals
-            if _locs_ is None:
-                _locs_ = frame.f_locals
-            del frame
-        elif _locs_ is None:
-            _locs_ = _globs_
-        exec("""exec _code_ in _globs_, _locs_""")
-
-    exec_("""def reraise(tp, value, tb=None):
-    raise tp, value, tb
-""")
-
-
-if sys.version_info[:2] == (3, 2):
-    exec_("""def raise_from(value, from_value):
-    if from_value is None:
-        raise value
-    raise value from from_value
-""")
-elif sys.version_info[:2] > (3, 2):
-    exec_("""def raise_from(value, from_value):
-    raise value from from_value
-""")
-else:
-    def raise_from(value, from_value):
-        raise value
-
-
-print_ = getattr(moves.builtins, "print", None)
-if print_ is None:
-    def print_(*args, **kwargs):
-        """The new-style print function for Python 2.4 and 2.5."""
-        fp = kwargs.pop("file", sys.stdout)
-        if fp is None:
-            return
-
-        def write(data):
-            if not isinstance(data, basestring):
-                data = str(data)
-            # If the file has an encoding, encode unicode with it.
-            if (isinstance(fp, file) and
-                    isinstance(data, unicode) and
-                    fp.encoding is not None):
-                errors = getattr(fp, "errors", None)
-                if errors is None:
-                    errors = "strict"
-                data = data.encode(fp.encoding, errors)
-            fp.write(data)
-        want_unicode = False
-        sep = kwargs.pop("sep", None)
-        if sep is not None:
-            if isinstance(sep, unicode):
-                want_unicode = True
-            elif not isinstance(sep, str):
-                raise TypeError("sep must be None or a string")
-        end = kwargs.pop("end", None)
-        if end is not None:
-            if isinstance(end, unicode):
-                want_unicode = True
-            elif not isinstance(end, str):
-                raise TypeError("end must be None or a string")
-        if kwargs:
-            raise TypeError("invalid keyword arguments to print()")
-        if not want_unicode:
-            for arg in args:
-                if isinstance(arg, unicode):
-                    want_unicode = True
-                    break
-        if want_unicode:
-            newline = unicode("\n")
-            space = unicode(" ")
-        else:
-            newline = "\n"
-            space = " "
-        if sep is None:
-            sep = space
-        if end is None:
-            end = newline
-        for i, arg in enumerate(args):
-            if i:
-                write(sep)
-            write(arg)
-        write(end)
-if sys.version_info[:2] < (3, 3):
-    _print = print_
-
-    def print_(*args, **kwargs):
-        fp = kwargs.get("file", sys.stdout)
-        flush = kwargs.pop("flush", False)
-        _print(*args, **kwargs)
-        if flush and fp is not None:
-            fp.flush()
-
-_add_doc(reraise, """Reraise an exception.""")
-
-if sys.version_info[0:2] < (3, 4):
-    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
-              updated=functools.WRAPPER_UPDATES):
-        def wrapper(f):
-            f = functools.wraps(wrapped, assigned, updated)(f)
-            f.__wrapped__ = wrapped
-            return f
-        return wrapper
-else:
-    wraps = functools.wraps
-
-
-def with_metaclass(meta, *bases):
-    """Create a base class with a metaclass."""
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
-    class metaclass(meta):
-
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
-
-
-def add_metaclass(metaclass):
-    """Class decorator for creating a class with a metaclass."""
-    def wrapper(cls):
-        orig_vars = cls.__dict__.copy()
-        slots = orig_vars.get('__slots__')
-        if slots is not None:
-            if isinstance(slots, str):
-                slots = [slots]
-            for slots_var in slots:
-                orig_vars.pop(slots_var)
-        orig_vars.pop('__dict__', None)
-        orig_vars.pop('__weakref__', None)
-        return metaclass(cls.__name__, cls.__bases__, orig_vars)
-    return wrapper
-
-
-def python_2_unicode_compatible(klass):
-    """
-    A decorator that defines __unicode__ and __str__ methods under Python 2.
-    Under Python 3 it does nothing.
-
-    To support Python 2 and 3 with a single code base, define a __str__ method
-    returning text and apply this decorator to the class.
-    """
-    if PY2:
-        if '__str__' not in klass.__dict__:
-            raise ValueError("@python_2_unicode_compatible cannot be applied "
-                             "to %s because it doesn't define __str__()." %
-                             klass.__name__)
-        klass.__unicode__ = klass.__str__
-        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
-    return klass
-
-
-# Complete the moves implementation.
-# This code is at the end of this module to speed up module loading.
-# Turn this module into a package.
-__path__ = []  # required for PEP 302 and PEP 451
-__package__ = __name__  # see PEP 366 @ReservedAssignment
-if globals().get("__spec__") is not None:
-    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
-# Remove other six meta path importers, since they cause problems. This can
-# happen if six is removed from sys.modules and then reloaded. (Setuptools does
-# this for some reason.)
-if sys.meta_path:
-    for i, importer in enumerate(sys.meta_path):
-        # Here's some real nastiness: Another "instance" of the six module might
-        # be floating around. Therefore, we can't use isinstance() to check for
-        # the six meta path importer, since the other six instance will have
-        # inserted an importer with different class.
-        if (type(importer).__name__ == "_SixMetaPathImporter" and
-                importer.name == __name__):
-            del sys.meta_path[i]
-            break
-    del i, importer
-# Finally, add the importer to the meta path import hook.
-sys.meta_path.append(_importer)
+"""Utilities for writing code that runs on Python 2 and 3""" 
+ 
+# Copyright (c) 2010-2015 Benjamin Peterson 
+# 
+# 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 __future__ import absolute_import 
+ 
+import functools 
+import itertools 
+import operator 
+import sys 
+import types 
+ 
+__author__ = "Benjamin Peterson <benjamin@python.org>" 
+__version__ = "1.10.0" 
+ 
+ 
+# Useful for very coarse version differentiation. 
+PY2 = sys.version_info[0] == 2 
+PY3 = sys.version_info[0] == 3 
+PY34 = sys.version_info[0:2] >= (3, 4) 
+ 
+if PY3: 
+    string_types = str, 
+    integer_types = int, 
+    class_types = type, 
+    text_type = str 
+    binary_type = bytes 
+ 
+    MAXSIZE = sys.maxsize 
+else: 
+    string_types = basestring, 
+    integer_types = (int, long) 
+    class_types = (type, types.ClassType) 
+    text_type = unicode 
+    binary_type = str 
+ 
+    if sys.platform.startswith("java"): 
+        # Jython always uses 32 bits. 
+        MAXSIZE = int((1 << 31) - 1) 
+    else: 
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t). 
+        class X(object): 
+ 
+            def __len__(self): 
+                return 1 << 31 
+        try: 
+            len(X()) 
+        except OverflowError: 
+            # 32-bit 
+            MAXSIZE = int((1 << 31) - 1) 
+        else: 
+            # 64-bit 
+            MAXSIZE = int((1 << 63) - 1) 
+        del X 
+ 
+ 
+def _add_doc(func, doc): 
+    """Add documentation to a function.""" 
+    func.__doc__ = doc 
+ 
+ 
+def _import_module(name): 
+    """Import module, returning the module after the last dot.""" 
+    __import__(name) 
+    return sys.modules[name] 
+ 
+ 
+class _LazyDescr(object): 
+ 
+    def __init__(self, name): 
+        self.name = name 
+ 
+    def __get__(self, obj, tp): 
+        result = self._resolve() 
+        setattr(obj, self.name, result)  # Invokes __set__. 
+        try: 
+            # This is a bit ugly, but it avoids running this again by 
+            # removing this descriptor. 
+            delattr(obj.__class__, self.name) 
+        except AttributeError: 
+            pass 
+        return result 
+ 
+ 
+class MovedModule(_LazyDescr): 
+ 
+    def __init__(self, name, old, new=None): 
+        super(MovedModule, self).__init__(name) 
+        if PY3: 
+            if new is None: 
+                new = name 
+            self.mod = new 
+        else: 
+            self.mod = old 
+ 
+    def _resolve(self): 
+        return _import_module(self.mod) 
+ 
+    def __getattr__(self, attr): 
+        _module = self._resolve() 
+        value = getattr(_module, attr) 
+        setattr(self, attr, value) 
+        return value 
+ 
+ 
+class _LazyModule(types.ModuleType): 
+ 
+    def __init__(self, name): 
+        super(_LazyModule, self).__init__(name) 
+        self.__doc__ = self.__class__.__doc__ 
+ 
+    def __dir__(self): 
+        attrs = ["__doc__", "__name__"] 
+        attrs += [attr.name for attr in self._moved_attributes] 
+        return attrs 
+ 
+    # Subclasses should override this 
+    _moved_attributes = [] 
+ 
+ 
+class MovedAttribute(_LazyDescr): 
+ 
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): 
+        super(MovedAttribute, self).__init__(name) 
+        if PY3: 
+            if new_mod is None: 
+                new_mod = name 
+            self.mod = new_mod 
+            if new_attr is None: 
+                if old_attr is None: 
+                    new_attr = name 
+                else: 
+                    new_attr = old_attr 
+            self.attr = new_attr 
+        else: 
+            self.mod = old_mod 
+            if old_attr is None: 
+                old_attr = name 
+            self.attr = old_attr 
+ 
+    def _resolve(self): 
+        module = _import_module(self.mod) 
+        return getattr(module, self.attr) 
+ 
+ 
+class _SixMetaPathImporter(object): 
+ 
+    """ 
+    A meta path importer to import six.moves and its submodules. 
+ 
+    This class implements a PEP302 finder and loader. It should be compatible 
+    with Python 2.5 and all existing versions of Python3 
+    """ 
+ 
+    def __init__(self, six_module_name): 
+        self.name = six_module_name 
+        self.known_modules = {} 
+ 
+    def _add_module(self, mod, *fullnames): 
+        for fullname in fullnames: 
+            self.known_modules[self.name + "." + fullname] = mod 
+ 
+    def _get_module(self, fullname): 
+        return self.known_modules[self.name + "." + fullname] 
+ 
+    def find_module(self, fullname, path=None): 
+        if fullname in self.known_modules: 
+            return self 
+        return None 
+ 
+    def __get_module(self, fullname): 
+        try: 
+            return self.known_modules[fullname] 
+        except KeyError: 
+            raise ImportError("This loader does not know module " + fullname) 
+ 
+    def load_module(self, fullname): 
+        try: 
+            # in case of a reload 
+            return sys.modules[fullname] 
+        except KeyError: 
+            pass 
+        mod = self.__get_module(fullname) 
+        if isinstance(mod, MovedModule): 
+            mod = mod._resolve() 
+        else: 
+            mod.__loader__ = self 
+        sys.modules[fullname] = mod 
+        return mod 
+ 
+    def is_package(self, fullname): 
+        """ 
+        Return true, if the named module is a package. 
+ 
+        We need this method to get correct spec objects with 
+        Python 3.4 (see PEP451) 
+        """ 
+        return hasattr(self.__get_module(fullname), "__path__") 
+ 
+    def get_code(self, fullname): 
+        """Return None 
+ 
+        Required, if is_package is implemented""" 
+        self.__get_module(fullname)  # eventually raises ImportError 
+        return None 
+    get_source = get_code  # same as get_code 
+ 
+_importer = _SixMetaPathImporter(__name__) 
+ 
+ 
+class _MovedItems(_LazyModule): 
+ 
+    """Lazy loading of moved objects""" 
+    __path__ = []  # mark as package 
+ 
+ 
+_moved_attributes = [ 
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), 
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), 
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), 
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), 
+    MovedAttribute("intern", "__builtin__", "sys"), 
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"), 
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), 
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), 
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), 
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"), 
+    MovedAttribute("reduce", "__builtin__", "functools"), 
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), 
+    MovedAttribute("StringIO", "StringIO", "io"), 
+    MovedAttribute("UserDict", "UserDict", "collections"), 
+    MovedAttribute("UserList", "UserList", "collections"), 
+    MovedAttribute("UserString", "UserString", "collections"), 
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), 
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), 
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), 
+    MovedModule("builtins", "__builtin__"), 
+    MovedModule("configparser", "ConfigParser"), 
+    MovedModule("copyreg", "copy_reg"), 
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), 
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"), 
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), 
+    MovedModule("http_cookies", "Cookie", "http.cookies"), 
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"), 
+    MovedModule("html_parser", "HTMLParser", "html.parser"), 
+    MovedModule("http_client", "httplib", "http.client"), 
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), 
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), 
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), 
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), 
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), 
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), 
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), 
+    MovedModule("cPickle", "cPickle", "pickle"), 
+    MovedModule("queue", "Queue"), 
+    MovedModule("reprlib", "repr"), 
+    MovedModule("socketserver", "SocketServer"), 
+    MovedModule("_thread", "thread", "_thread"), 
+    MovedModule("tkinter", "Tkinter"), 
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), 
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), 
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), 
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), 
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"), 
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), 
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), 
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), 
+    MovedModule("tkinter_colorchooser", "tkColorChooser", 
+                "tkinter.colorchooser"), 
+    MovedModule("tkinter_commondialog", "tkCommonDialog", 
+                "tkinter.commondialog"), 
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), 
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"), 
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), 
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", 
+                "tkinter.simpledialog"), 
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), 
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), 
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), 
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), 
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), 
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), 
+] 
+# Add windows specific modules. 
+if sys.platform == "win32": 
+    _moved_attributes += [ 
+        MovedModule("winreg", "_winreg"), 
+    ] 
+ 
+for attr in _moved_attributes: 
+    setattr(_MovedItems, attr.name, attr) 
+    if isinstance(attr, MovedModule): 
+        _importer._add_module(attr, "moves." + attr.name) 
+del attr 
+ 
+_MovedItems._moved_attributes = _moved_attributes 
+ 
+moves = _MovedItems(__name__ + ".moves") 
+_importer._add_module(moves, "moves") 
+ 
+ 
+class Module_six_moves_urllib_parse(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_parse""" 
+ 
+ 
+_urllib_parse_moved_attributes = [ 
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"), 
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"), 
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"), 
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), 
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"), 
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"), 
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), 
+    MovedAttribute("quote", "urllib", "urllib.parse"), 
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"), 
+    MovedAttribute("unquote", "urllib", "urllib.parse"), 
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"), 
+    MovedAttribute("urlencode", "urllib", "urllib.parse"), 
+    MovedAttribute("splitquery", "urllib", "urllib.parse"), 
+    MovedAttribute("splittag", "urllib", "urllib.parse"), 
+    MovedAttribute("splituser", "urllib", "urllib.parse"), 
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"), 
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"), 
+] 
+for attr in _urllib_parse_moved_attributes: 
+    setattr(Module_six_moves_urllib_parse, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), 
+                      "moves.urllib_parse", "moves.urllib.parse") 
+ 
+ 
+class Module_six_moves_urllib_error(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_error""" 
+ 
+ 
+_urllib_error_moved_attributes = [ 
+    MovedAttribute("URLError", "urllib2", "urllib.error"), 
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"), 
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), 
+] 
+for attr in _urllib_error_moved_attributes: 
+    setattr(Module_six_moves_urllib_error, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), 
+                      "moves.urllib_error", "moves.urllib.error") 
+ 
+ 
+class Module_six_moves_urllib_request(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_request""" 
+ 
+ 
+_urllib_request_moved_attributes = [ 
+    MovedAttribute("urlopen", "urllib2", "urllib.request"), 
+    MovedAttribute("install_opener", "urllib2", "urllib.request"), 
+    MovedAttribute("build_opener", "urllib2", "urllib.request"), 
+    MovedAttribute("pathname2url", "urllib", "urllib.request"), 
+    MovedAttribute("url2pathname", "urllib", "urllib.request"), 
+    MovedAttribute("getproxies", "urllib", "urllib.request"), 
+    MovedAttribute("Request", "urllib2", "urllib.request"), 
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), 
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), 
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), 
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), 
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"), 
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"), 
+    MovedAttribute("URLopener", "urllib", "urllib.request"), 
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"), 
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"), 
+] 
+for attr in _urllib_request_moved_attributes: 
+    setattr(Module_six_moves_urllib_request, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), 
+                      "moves.urllib_request", "moves.urllib.request") 
+ 
+ 
+class Module_six_moves_urllib_response(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_response""" 
+ 
+ 
+_urllib_response_moved_attributes = [ 
+    MovedAttribute("addbase", "urllib", "urllib.response"), 
+    MovedAttribute("addclosehook", "urllib", "urllib.response"), 
+    MovedAttribute("addinfo", "urllib", "urllib.response"), 
+    MovedAttribute("addinfourl", "urllib", "urllib.response"), 
+] 
+for attr in _urllib_response_moved_attributes: 
+    setattr(Module_six_moves_urllib_response, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), 
+                      "moves.urllib_response", "moves.urllib.response") 
+ 
+ 
+class Module_six_moves_urllib_robotparser(_LazyModule): 
+ 
+    """Lazy loading of moved objects in six.moves.urllib_robotparser""" 
+ 
+ 
+_urllib_robotparser_moved_attributes = [ 
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), 
+] 
+for attr in _urllib_robotparser_moved_attributes: 
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr) 
+del attr 
+ 
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes 
+ 
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), 
+                      "moves.urllib_robotparser", "moves.urllib.robotparser") 
+ 
+ 
+class Module_six_moves_urllib(types.ModuleType): 
+ 
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" 
+    __path__ = []  # mark as package 
+    parse = _importer._get_module("moves.urllib_parse") 
+    error = _importer._get_module("moves.urllib_error") 
+    request = _importer._get_module("moves.urllib_request") 
+    response = _importer._get_module("moves.urllib_response") 
+    robotparser = _importer._get_module("moves.urllib_robotparser") 
+ 
+    def __dir__(self): 
+        return ['parse', 'error', 'request', 'response', 'robotparser'] 
+ 
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), 
+                      "moves.urllib") 
+ 
+ 
+def add_move(move): 
+    """Add an item to six.moves.""" 
+    setattr(_MovedItems, move.name, move) 
+ 
+ 
+def remove_move(name): 
+    """Remove item from six.moves.""" 
+    try: 
+        delattr(_MovedItems, name) 
+    except AttributeError: 
+        try: 
+            del moves.__dict__[name] 
+        except KeyError: 
+            raise AttributeError("no such move, %r" % (name,)) 
+ 
+ 
+if PY3: 
+    _meth_func = "__func__" 
+    _meth_self = "__self__" 
+ 
+    _func_closure = "__closure__" 
+    _func_code = "__code__" 
+    _func_defaults = "__defaults__" 
+    _func_globals = "__globals__" 
+else: 
+    _meth_func = "im_func" 
+    _meth_self = "im_self" 
+ 
+    _func_closure = "func_closure" 
+    _func_code = "func_code" 
+    _func_defaults = "func_defaults" 
+    _func_globals = "func_globals" 
+ 
+ 
+try: 
+    advance_iterator = next 
+except NameError: 
+    def advance_iterator(it): 
+        return it.next() 
+next = advance_iterator 
+ 
+ 
+try: 
+    callable = callable 
+except NameError: 
+    def callable(obj): 
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) 
+ 
+ 
+if PY3: 
+    def get_unbound_function(unbound): 
+        return unbound 
+ 
+    create_bound_method = types.MethodType 
+ 
+    def create_unbound_method(func, cls): 
+        return func 
+ 
+    Iterator = object 
+else: 
+    def get_unbound_function(unbound): 
+        return unbound.im_func 
+ 
+    def create_bound_method(func, obj): 
+        return types.MethodType(func, obj, obj.__class__) 
+ 
+    def create_unbound_method(func, cls): 
+        return types.MethodType(func, None, cls) 
+ 
+    class Iterator(object): 
+ 
+        def next(self): 
+            return type(self).__next__(self) 
+ 
+    callable = callable 
+_add_doc(get_unbound_function, 
+         """Get the function out of a possibly unbound function""") 
+ 
+ 
+get_method_function = operator.attrgetter(_meth_func) 
+get_method_self = operator.attrgetter(_meth_self) 
+get_function_closure = operator.attrgetter(_func_closure) 
+get_function_code = operator.attrgetter(_func_code) 
+get_function_defaults = operator.attrgetter(_func_defaults) 
+get_function_globals = operator.attrgetter(_func_globals) 
+ 
+ 
+if PY3: 
+    def iterkeys(d, **kw): 
+        return iter(d.keys(**kw)) 
+ 
+    def itervalues(d, **kw): 
+        return iter(d.values(**kw)) 
+ 
+    def iteritems(d, **kw): 
+        return iter(d.items(**kw)) 
+ 
+    def iterlists(d, **kw): 
+        return iter(d.lists(**kw)) 
+ 
+    viewkeys = operator.methodcaller("keys") 
+ 
+    viewvalues = operator.methodcaller("values") 
+ 
+    viewitems = operator.methodcaller("items") 
+else: 
+    def iterkeys(d, **kw): 
+        return d.iterkeys(**kw) 
+ 
+    def itervalues(d, **kw): 
+        return d.itervalues(**kw) 
+ 
+    def iteritems(d, **kw): 
+        return d.iteritems(**kw) 
+ 
+    def iterlists(d, **kw): 
+        return d.iterlists(**kw) 
+ 
+    viewkeys = operator.methodcaller("viewkeys") 
+ 
+    viewvalues = operator.methodcaller("viewvalues") 
+ 
+    viewitems = operator.methodcaller("viewitems") 
+ 
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") 
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.") 
+_add_doc(iteritems, 
+         "Return an iterator over the (key, value) pairs of a dictionary.") 
+_add_doc(iterlists, 
+         "Return an iterator over the (key, [values]) pairs of a dictionary.") 
+ 
+ 
+if PY3: 
+    def b(s): 
+        return s.encode("latin-1") 
+ 
+    def u(s): 
+        return s 
+    unichr = chr 
+    import struct 
+    int2byte = struct.Struct(">B").pack 
+    del struct 
+    byte2int = operator.itemgetter(0) 
+    indexbytes = operator.getitem 
+    iterbytes = iter 
+    import io 
+    StringIO = io.StringIO 
+    BytesIO = io.BytesIO 
+    _assertCountEqual = "assertCountEqual" 
+    if sys.version_info[1] <= 1: 
+        _assertRaisesRegex = "assertRaisesRegexp" 
+        _assertRegex = "assertRegexpMatches" 
+    else: 
+        _assertRaisesRegex = "assertRaisesRegex" 
+        _assertRegex = "assertRegex" 
+else: 
+    def b(s): 
+        return s 
+    # Workaround for standalone backslash 
+ 
+    def u(s): 
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape") 
+    unichr = unichr 
+    int2byte = chr 
+ 
+    def byte2int(bs): 
+        return ord(bs[0]) 
+ 
+    def indexbytes(buf, i): 
+        return ord(buf[i]) 
+    iterbytes = functools.partial(itertools.imap, ord) 
+    import StringIO 
+    StringIO = BytesIO = StringIO.StringIO 
+    _assertCountEqual = "assertItemsEqual" 
+    _assertRaisesRegex = "assertRaisesRegexp" 
+    _assertRegex = "assertRegexpMatches" 
+_add_doc(b, """Byte literal""") 
+_add_doc(u, """Text literal""") 
+ 
+ 
+def assertCountEqual(self, *args, **kwargs): 
+    return getattr(self, _assertCountEqual)(*args, **kwargs) 
+ 
+ 
+def assertRaisesRegex(self, *args, **kwargs): 
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs) 
+ 
+ 
+def assertRegex(self, *args, **kwargs): 
+    return getattr(self, _assertRegex)(*args, **kwargs) 
+ 
+ 
+if PY3: 
+    exec_ = getattr(moves.builtins, "exec") 
+ 
+    def reraise(tp, value, tb=None): 
+        if value is None: 
+            value = tp() 
+        if value.__traceback__ is not tb: 
+            raise value.with_traceback(tb) 
+        raise value 
+ 
+else: 
+    def exec_(_code_, _globs_=None, _locs_=None): 
+        """Execute code in a namespace.""" 
+        if _globs_ is None: 
+            frame = sys._getframe(1) 
+            _globs_ = frame.f_globals 
+            if _locs_ is None: 
+                _locs_ = frame.f_locals 
+            del frame 
+        elif _locs_ is None: 
+            _locs_ = _globs_ 
+        exec("""exec _code_ in _globs_, _locs_""") 
+ 
+    exec_("""def reraise(tp, value, tb=None): 
+    raise tp, value, tb 
+""") 
+ 
+ 
+if sys.version_info[:2] == (3, 2): 
+    exec_("""def raise_from(value, from_value): 
+    if from_value is None: 
+        raise value 
+    raise value from from_value 
+""") 
+elif sys.version_info[:2] > (3, 2): 
+    exec_("""def raise_from(value, from_value): 
+    raise value from from_value 
+""") 
+else: 
+    def raise_from(value, from_value): 
+        raise value 
+ 
+ 
+print_ = getattr(moves.builtins, "print", None) 
+if print_ is None: 
+    def print_(*args, **kwargs): 
+        """The new-style print function for Python 2.4 and 2.5.""" 
+        fp = kwargs.pop("file", sys.stdout) 
+        if fp is None: 
+            return 
+ 
+        def write(data): 
+            if not isinstance(data, basestring): 
+                data = str(data) 
+            # If the file has an encoding, encode unicode with it. 
+            if (isinstance(fp, file) and 
+                    isinstance(data, unicode) and 
+                    fp.encoding is not None): 
+                errors = getattr(fp, "errors", None) 
+                if errors is None: 
+                    errors = "strict" 
+                data = data.encode(fp.encoding, errors) 
+            fp.write(data) 
+        want_unicode = False 
+        sep = kwargs.pop("sep", None) 
+        if sep is not None: 
+            if isinstance(sep, unicode): 
+                want_unicode = True 
+            elif not isinstance(sep, str): 
+                raise TypeError("sep must be None or a string") 
+        end = kwargs.pop("end", None) 
+        if end is not None: 
+            if isinstance(end, unicode): 
+                want_unicode = True 
+            elif not isinstance(end, str): 
+                raise TypeError("end must be None or a string") 
+        if kwargs: 
+            raise TypeError("invalid keyword arguments to print()") 
+        if not want_unicode: 
+            for arg in args: 
+                if isinstance(arg, unicode): 
+                    want_unicode = True 
+                    break 
+        if want_unicode: 
+            newline = unicode("\n") 
+            space = unicode(" ") 
+        else: 
+            newline = "\n" 
+            space = " " 
+        if sep is None: 
+            sep = space 
+        if end is None: 
+            end = newline 
+        for i, arg in enumerate(args): 
+            if i: 
+                write(sep) 
+            write(arg) 
+        write(end) 
+if sys.version_info[:2] < (3, 3): 
+    _print = print_ 
+ 
+    def print_(*args, **kwargs): 
+        fp = kwargs.get("file", sys.stdout) 
+        flush = kwargs.pop("flush", False) 
+        _print(*args, **kwargs) 
+        if flush and fp is not None: 
+            fp.flush() 
+ 
+_add_doc(reraise, """Reraise an exception.""") 
+ 
+if sys.version_info[0:2] < (3, 4): 
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, 
+              updated=functools.WRAPPER_UPDATES): 
+        def wrapper(f): 
+            f = functools.wraps(wrapped, assigned, updated)(f) 
+            f.__wrapped__ = wrapped 
+            return f 
+        return wrapper 
+else: 
+    wraps = functools.wraps 
+ 
+ 
+def with_metaclass(meta, *bases): 
+    """Create a base class with a metaclass.""" 
+    # This requires a bit of explanation: the basic idea is to make a dummy 
+    # metaclass for one level of class instantiation that replaces itself with 
+    # the actual metaclass. 
+    class metaclass(meta): 
+ 
+        def __new__(cls, name, this_bases, d): 
+            return meta(name, bases, d) 
+    return type.__new__(metaclass, 'temporary_class', (), {}) 
+ 
+ 
+def add_metaclass(metaclass): 
+    """Class decorator for creating a class with a metaclass.""" 
+    def wrapper(cls): 
+        orig_vars = cls.__dict__.copy() 
+        slots = orig_vars.get('__slots__') 
+        if slots is not None: 
+            if isinstance(slots, str): 
+                slots = [slots] 
+            for slots_var in slots: 
+                orig_vars.pop(slots_var) 
+        orig_vars.pop('__dict__', None) 
+        orig_vars.pop('__weakref__', None) 
+        return metaclass(cls.__name__, cls.__bases__, orig_vars) 
+    return wrapper 
+ 
+ 
+def python_2_unicode_compatible(klass): 
+    """ 
+    A decorator that defines __unicode__ and __str__ methods under Python 2. 
+    Under Python 3 it does nothing. 
+ 
+    To support Python 2 and 3 with a single code base, define a __str__ method 
+    returning text and apply this decorator to the class. 
+    """ 
+    if PY2: 
+        if '__str__' not in klass.__dict__: 
+            raise ValueError("@python_2_unicode_compatible cannot be applied " 
+                             "to %s because it doesn't define __str__()." % 
+                             klass.__name__) 
+        klass.__unicode__ = klass.__str__ 
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8') 
+    return klass 
+ 
+ 
+# Complete the moves implementation. 
+# This code is at the end of this module to speed up module loading. 
+# Turn this module into a package. 
+__path__ = []  # required for PEP 302 and PEP 451 
+__package__ = __name__  # see PEP 366 @ReservedAssignment 
+if globals().get("__spec__") is not None: 
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable 
+# Remove other six meta path importers, since they cause problems. This can 
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does 
+# this for some reason.) 
+if sys.meta_path: 
+    for i, importer in enumerate(sys.meta_path): 
+        # Here's some real nastiness: Another "instance" of the six module might 
+        # be floating around. Therefore, we can't use isinstance() to check for 
+        # the six meta path importer, since the other six instance will have 
+        # inserted an importer with different class. 
+        if (type(importer).__name__ == "_SixMetaPathImporter" and 
+                importer.name == __name__): 
+            del sys.meta_path[i] 
+            break 
+    del i, importer 
+# Finally, add the importer to the meta path import hook. 
+sys.meta_path.append(_importer) 
diff --git a/contrib/python/setuptools/py2/setuptools/archive_util.py b/contrib/python/setuptools/py2/setuptools/archive_util.py
index 81436044d9..16cf179416 100644
--- a/contrib/python/setuptools/py2/setuptools/archive_util.py
+++ b/contrib/python/setuptools/py2/setuptools/archive_util.py
@@ -8,7 +8,7 @@ import posixpath
 import contextlib
 from distutils.errors import DistutilsError
 
-from pkg_resources import ensure_directory
+from pkg_resources import ensure_directory 
 
 __all__ = [
     "unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
@@ -98,7 +98,7 @@ def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
     if not zipfile.is_zipfile(filename):
         raise UnrecognizedFormat("%s is not a zip file" % (filename,))
 
-    with zipfile.ZipFile(filename) as z:
+    with zipfile.ZipFile(filename) as z: 
         for info in z.infolist():
             name = info.filename
 
diff --git a/contrib/python/setuptools/py2/setuptools/build_meta.py b/contrib/python/setuptools/py2/setuptools/build_meta.py
index eb9e815ef8..dcdd53db94 100644
--- a/contrib/python/setuptools/py2/setuptools/build_meta.py
+++ b/contrib/python/setuptools/py2/setuptools/build_meta.py
@@ -1,264 +1,264 @@
-"""A PEP 517 interface to setuptools
-
-Previously, when a user or a command line tool (let's call it a "frontend")
-needed to make a request of setuptools to take a certain action, for
-example, generating a list of installation requirements, the frontend would
-would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line.
-
-PEP 517 defines a different method of interfacing with setuptools. Rather
-than calling "setup.py" directly, the frontend should:
-
-  1. Set the current directory to the directory with a setup.py file
-  2. Import this module into a safe python interpreter (one in which
-     setuptools can potentially set global variables or crash hard).
-  3. Call one of the functions defined in PEP 517.
-
-What each function does is defined in PEP 517. However, here is a "casual"
-definition of the functions (this definition should not be relied on for
-bug reports or API stability):
-
-  - `build_wheel`: build a wheel in the folder and return the basename
-  - `get_requires_for_build_wheel`: get the `setup_requires` to build
-  - `prepare_metadata_for_build_wheel`: get the `install_requires`
-  - `build_sdist`: build an sdist in the folder and return the basename
-  - `get_requires_for_build_sdist`: get the `setup_requires` to build
-
-Again, this is not a formal definition! Just a "taste" of the module.
-"""
-
-import io
-import os
-import sys
-import tokenize
-import shutil
-import contextlib
-
-import setuptools
-import distutils
-from setuptools.py31compat import TemporaryDirectory
-
-from pkg_resources import parse_requirements
-from pkg_resources.py31compat import makedirs
-
-__all__ = ['get_requires_for_build_sdist',
-           'get_requires_for_build_wheel',
-           'prepare_metadata_for_build_wheel',
-           'build_wheel',
-           'build_sdist',
-           '__legacy__',
-           'SetupRequirementsError']
-
-class SetupRequirementsError(BaseException):
-    def __init__(self, specifiers):
-        self.specifiers = specifiers
-
-
-class Distribution(setuptools.dist.Distribution):
-    def fetch_build_eggs(self, specifiers):
-        specifier_list = list(map(str, parse_requirements(specifiers)))
-
-        raise SetupRequirementsError(specifier_list)
-
-    @classmethod
-    @contextlib.contextmanager
-    def patch(cls):
-        """
-        Replace
-        distutils.dist.Distribution with this class
-        for the duration of this context.
-        """
-        orig = distutils.core.Distribution
-        distutils.core.Distribution = cls
-        try:
-            yield
-        finally:
-            distutils.core.Distribution = orig
-
-
-def _to_str(s):
-    """
-    Convert a filename to a string (on Python 2, explicitly
-    a byte string, not Unicode) as distutils checks for the
-    exact type str.
-    """
-    if sys.version_info[0] == 2 and not isinstance(s, str):
-        # Assume it's Unicode, as that's what the PEP says
-        # should be provided.
-        return s.encode(sys.getfilesystemencoding())
-    return s
-
-
-def _get_immediate_subdirectories(a_dir):
-    return [name for name in os.listdir(a_dir)
-            if os.path.isdir(os.path.join(a_dir, name))]
-
-
-def _file_with_extension(directory, extension):
-    matching = (
-        f for f in os.listdir(directory)
-        if f.endswith(extension)
-    )
-    file, = matching
-    return file
-
-
-def _open_setup_script(setup_script):
-    if not os.path.exists(setup_script):
-        # Supply a default setup.py
-        return io.StringIO(u"from setuptools import setup; setup()")
-
-    return getattr(tokenize, 'open', open)(setup_script)
-
-
-class _BuildMetaBackend(object):
-
-    def _fix_config(self, config_settings):
-        config_settings = config_settings or {}
-        config_settings.setdefault('--global-option', [])
-        return config_settings
-
-    def _get_build_requires(self, config_settings, requirements):
-        config_settings = self._fix_config(config_settings)
-
-        sys.argv = sys.argv[:1] + ['egg_info'] + \
-            config_settings["--global-option"]
-        try:
-            with Distribution.patch():
-                self.run_setup()
-        except SetupRequirementsError as e:
-            requirements += e.specifiers
-
-        return requirements
-
-    def run_setup(self, setup_script='setup.py'):
-        # Note that we can reuse our build directory between calls
-        # Correctness comes first, then optimization later
-        __file__ = setup_script
-        __name__ = '__main__'
-
-        with _open_setup_script(__file__) as f:
-            code = f.read().replace(r'\r\n', r'\n')
-
-        exec(compile(code, __file__, 'exec'), locals())
-
-    def get_requires_for_build_wheel(self, config_settings=None):
-        config_settings = self._fix_config(config_settings)
-        return self._get_build_requires(config_settings, requirements=['wheel'])
-
-    def get_requires_for_build_sdist(self, config_settings=None):
-        config_settings = self._fix_config(config_settings)
-        return self._get_build_requires(config_settings, requirements=[])
-
-    def prepare_metadata_for_build_wheel(self, metadata_directory,
-                                         config_settings=None):
-        sys.argv = sys.argv[:1] + ['dist_info', '--egg-base',
-                                   _to_str(metadata_directory)]
-        self.run_setup()
-
-        dist_info_directory = metadata_directory
-        while True:
-            dist_infos = [f for f in os.listdir(dist_info_directory)
-                          if f.endswith('.dist-info')]
-
-            if (len(dist_infos) == 0 and
-                len(_get_immediate_subdirectories(dist_info_directory)) == 1):
-
-                dist_info_directory = os.path.join(
-                    dist_info_directory, os.listdir(dist_info_directory)[0])
-                continue
-
-            assert len(dist_infos) == 1
-            break
-
-        # PEP 517 requires that the .dist-info directory be placed in the
-        # metadata_directory. To comply, we MUST copy the directory to the root
-        if dist_info_directory != metadata_directory:
-            shutil.move(
-                os.path.join(dist_info_directory, dist_infos[0]),
-                metadata_directory)
-            shutil.rmtree(dist_info_directory, ignore_errors=True)
-
-        return dist_infos[0]
-
-    def _build_with_temp_dir(self, setup_command, result_extension,
-                             result_directory, config_settings):
-        config_settings = self._fix_config(config_settings)
-        result_directory = os.path.abspath(result_directory)
-
-        # Build in a temporary directory, then copy to the target.
-        makedirs(result_directory, exist_ok=True)
-        with TemporaryDirectory(dir=result_directory) as tmp_dist_dir:
-            sys.argv = (sys.argv[:1] + setup_command +
-                        ['--dist-dir', tmp_dist_dir] +
-                        config_settings["--global-option"])
-            self.run_setup()
-
-            result_basename = _file_with_extension(tmp_dist_dir, result_extension)
-            result_path = os.path.join(result_directory, result_basename)
-            if os.path.exists(result_path):
-                # os.rename will fail overwriting on non-Unix.
-                os.remove(result_path)
-            os.rename(os.path.join(tmp_dist_dir, result_basename), result_path)
-
-        return result_basename
-
-
-    def build_wheel(self, wheel_directory, config_settings=None,
-                    metadata_directory=None):
-        return self._build_with_temp_dir(['bdist_wheel'], '.whl',
-                                         wheel_directory, config_settings)
-
-    def build_sdist(self, sdist_directory, config_settings=None):
-        return self._build_with_temp_dir(['sdist', '--formats', 'gztar'],
-                                         '.tar.gz', sdist_directory,
-                                         config_settings)
-
-
-class _BuildMetaLegacyBackend(_BuildMetaBackend):
-    """Compatibility backend for setuptools
-
-    This is a version of setuptools.build_meta that endeavors to maintain backwards
-    compatibility with pre-PEP 517 modes of invocation. It exists as a temporary
-    bridge between the old packaging mechanism and the new packaging mechanism,
-    and will eventually be removed.
-    """
-    def run_setup(self, setup_script='setup.py'):
-        # In order to maintain compatibility with scripts assuming that
-        # the setup.py script is in a directory on the PYTHONPATH, inject
-        # '' into sys.path. (pypa/setuptools#1642)
-        sys_path = list(sys.path)           # Save the original path
-
-        script_dir = os.path.dirname(os.path.abspath(setup_script))
-        if script_dir not in sys.path:
-            sys.path.insert(0, script_dir)
-
-        # Some setup.py scripts (e.g. in pygame and numpy) use sys.argv[0] to
-        # get the directory of the source code. They expect it to refer to the
-        # setup.py script.
-        sys_argv_0 = sys.argv[0]
-        sys.argv[0] = setup_script
-
-        try:
-            super(_BuildMetaLegacyBackend,
-                  self).run_setup(setup_script=setup_script)
-        finally:
-            # While PEP 517 frontends should be calling each hook in a fresh
-            # subprocess according to the standard (and thus it should not be
-            # strictly necessary to restore the old sys.path), we'll restore
-            # the original path so that the path manipulation does not persist
-            # within the hook after run_setup is called.
-            sys.path[:] = sys_path
-            sys.argv[0] = sys_argv_0
-
-# The primary backend
-_BACKEND = _BuildMetaBackend()
-
-get_requires_for_build_wheel = _BACKEND.get_requires_for_build_wheel
-get_requires_for_build_sdist = _BACKEND.get_requires_for_build_sdist
-prepare_metadata_for_build_wheel = _BACKEND.prepare_metadata_for_build_wheel
-build_wheel = _BACKEND.build_wheel
-build_sdist = _BACKEND.build_sdist
-
-
-# The legacy backend
-__legacy__ = _BuildMetaLegacyBackend()
+"""A PEP 517 interface to setuptools 
+ 
+Previously, when a user or a command line tool (let's call it a "frontend") 
+needed to make a request of setuptools to take a certain action, for 
+example, generating a list of installation requirements, the frontend would 
+would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line. 
+ 
+PEP 517 defines a different method of interfacing with setuptools. Rather 
+than calling "setup.py" directly, the frontend should: 
+ 
+  1. Set the current directory to the directory with a setup.py file 
+  2. Import this module into a safe python interpreter (one in which 
+     setuptools can potentially set global variables or crash hard). 
+  3. Call one of the functions defined in PEP 517. 
+ 
+What each function does is defined in PEP 517. However, here is a "casual" 
+definition of the functions (this definition should not be relied on for 
+bug reports or API stability): 
+ 
+  - `build_wheel`: build a wheel in the folder and return the basename 
+  - `get_requires_for_build_wheel`: get the `setup_requires` to build 
+  - `prepare_metadata_for_build_wheel`: get the `install_requires` 
+  - `build_sdist`: build an sdist in the folder and return the basename 
+  - `get_requires_for_build_sdist`: get the `setup_requires` to build 
+ 
+Again, this is not a formal definition! Just a "taste" of the module. 
+""" 
+ 
+import io 
+import os 
+import sys 
+import tokenize 
+import shutil 
+import contextlib 
+ 
+import setuptools 
+import distutils 
+from setuptools.py31compat import TemporaryDirectory 
+ 
+from pkg_resources import parse_requirements 
+from pkg_resources.py31compat import makedirs 
+ 
+__all__ = ['get_requires_for_build_sdist', 
+           'get_requires_for_build_wheel', 
+           'prepare_metadata_for_build_wheel', 
+           'build_wheel', 
+           'build_sdist', 
+           '__legacy__', 
+           'SetupRequirementsError'] 
+ 
+class SetupRequirementsError(BaseException): 
+    def __init__(self, specifiers): 
+        self.specifiers = specifiers 
+ 
+ 
+class Distribution(setuptools.dist.Distribution): 
+    def fetch_build_eggs(self, specifiers): 
+        specifier_list = list(map(str, parse_requirements(specifiers))) 
+ 
+        raise SetupRequirementsError(specifier_list) 
+ 
+    @classmethod 
+    @contextlib.contextmanager 
+    def patch(cls): 
+        """ 
+        Replace 
+        distutils.dist.Distribution with this class 
+        for the duration of this context. 
+        """ 
+        orig = distutils.core.Distribution 
+        distutils.core.Distribution = cls 
+        try: 
+            yield 
+        finally: 
+            distutils.core.Distribution = orig 
+ 
+ 
+def _to_str(s): 
+    """ 
+    Convert a filename to a string (on Python 2, explicitly 
+    a byte string, not Unicode) as distutils checks for the 
+    exact type str. 
+    """ 
+    if sys.version_info[0] == 2 and not isinstance(s, str): 
+        # Assume it's Unicode, as that's what the PEP says 
+        # should be provided. 
+        return s.encode(sys.getfilesystemencoding()) 
+    return s 
+ 
+ 
+def _get_immediate_subdirectories(a_dir): 
+    return [name for name in os.listdir(a_dir) 
+            if os.path.isdir(os.path.join(a_dir, name))] 
+ 
+ 
+def _file_with_extension(directory, extension): 
+    matching = ( 
+        f for f in os.listdir(directory) 
+        if f.endswith(extension) 
+    ) 
+    file, = matching 
+    return file 
+ 
+ 
+def _open_setup_script(setup_script): 
+    if not os.path.exists(setup_script): 
+        # Supply a default setup.py 
+        return io.StringIO(u"from setuptools import setup; setup()") 
+ 
+    return getattr(tokenize, 'open', open)(setup_script) 
+ 
+ 
+class _BuildMetaBackend(object): 
+ 
+    def _fix_config(self, config_settings): 
+        config_settings = config_settings or {} 
+        config_settings.setdefault('--global-option', []) 
+        return config_settings 
+ 
+    def _get_build_requires(self, config_settings, requirements): 
+        config_settings = self._fix_config(config_settings) 
+ 
+        sys.argv = sys.argv[:1] + ['egg_info'] + \ 
+            config_settings["--global-option"] 
+        try: 
+            with Distribution.patch(): 
+                self.run_setup() 
+        except SetupRequirementsError as e: 
+            requirements += e.specifiers 
+ 
+        return requirements 
+ 
+    def run_setup(self, setup_script='setup.py'): 
+        # Note that we can reuse our build directory between calls 
+        # Correctness comes first, then optimization later 
+        __file__ = setup_script 
+        __name__ = '__main__' 
+ 
+        with _open_setup_script(__file__) as f: 
+            code = f.read().replace(r'\r\n', r'\n') 
+ 
+        exec(compile(code, __file__, 'exec'), locals()) 
+ 
+    def get_requires_for_build_wheel(self, config_settings=None): 
+        config_settings = self._fix_config(config_settings) 
+        return self._get_build_requires(config_settings, requirements=['wheel']) 
+ 
+    def get_requires_for_build_sdist(self, config_settings=None): 
+        config_settings = self._fix_config(config_settings) 
+        return self._get_build_requires(config_settings, requirements=[]) 
+ 
+    def prepare_metadata_for_build_wheel(self, metadata_directory, 
+                                         config_settings=None): 
+        sys.argv = sys.argv[:1] + ['dist_info', '--egg-base', 
+                                   _to_str(metadata_directory)] 
+        self.run_setup() 
+ 
+        dist_info_directory = metadata_directory 
+        while True: 
+            dist_infos = [f for f in os.listdir(dist_info_directory) 
+                          if f.endswith('.dist-info')] 
+ 
+            if (len(dist_infos) == 0 and 
+                len(_get_immediate_subdirectories(dist_info_directory)) == 1): 
+ 
+                dist_info_directory = os.path.join( 
+                    dist_info_directory, os.listdir(dist_info_directory)[0]) 
+                continue 
+ 
+            assert len(dist_infos) == 1 
+            break 
+ 
+        # PEP 517 requires that the .dist-info directory be placed in the 
+        # metadata_directory. To comply, we MUST copy the directory to the root 
+        if dist_info_directory != metadata_directory: 
+            shutil.move( 
+                os.path.join(dist_info_directory, dist_infos[0]), 
+                metadata_directory) 
+            shutil.rmtree(dist_info_directory, ignore_errors=True) 
+ 
+        return dist_infos[0] 
+ 
+    def _build_with_temp_dir(self, setup_command, result_extension, 
+                             result_directory, config_settings): 
+        config_settings = self._fix_config(config_settings) 
+        result_directory = os.path.abspath(result_directory) 
+ 
+        # Build in a temporary directory, then copy to the target. 
+        makedirs(result_directory, exist_ok=True) 
+        with TemporaryDirectory(dir=result_directory) as tmp_dist_dir: 
+            sys.argv = (sys.argv[:1] + setup_command + 
+                        ['--dist-dir', tmp_dist_dir] + 
+                        config_settings["--global-option"]) 
+            self.run_setup() 
+ 
+            result_basename = _file_with_extension(tmp_dist_dir, result_extension) 
+            result_path = os.path.join(result_directory, result_basename) 
+            if os.path.exists(result_path): 
+                # os.rename will fail overwriting on non-Unix. 
+                os.remove(result_path) 
+            os.rename(os.path.join(tmp_dist_dir, result_basename), result_path) 
+ 
+        return result_basename 
+ 
+ 
+    def build_wheel(self, wheel_directory, config_settings=None, 
+                    metadata_directory=None): 
+        return self._build_with_temp_dir(['bdist_wheel'], '.whl', 
+                                         wheel_directory, config_settings) 
+ 
+    def build_sdist(self, sdist_directory, config_settings=None): 
+        return self._build_with_temp_dir(['sdist', '--formats', 'gztar'], 
+                                         '.tar.gz', sdist_directory, 
+                                         config_settings) 
+ 
+ 
+class _BuildMetaLegacyBackend(_BuildMetaBackend): 
+    """Compatibility backend for setuptools 
+ 
+    This is a version of setuptools.build_meta that endeavors to maintain backwards 
+    compatibility with pre-PEP 517 modes of invocation. It exists as a temporary 
+    bridge between the old packaging mechanism and the new packaging mechanism, 
+    and will eventually be removed. 
+    """ 
+    def run_setup(self, setup_script='setup.py'): 
+        # In order to maintain compatibility with scripts assuming that 
+        # the setup.py script is in a directory on the PYTHONPATH, inject 
+        # '' into sys.path. (pypa/setuptools#1642) 
+        sys_path = list(sys.path)           # Save the original path 
+ 
+        script_dir = os.path.dirname(os.path.abspath(setup_script)) 
+        if script_dir not in sys.path: 
+            sys.path.insert(0, script_dir) 
+ 
+        # Some setup.py scripts (e.g. in pygame and numpy) use sys.argv[0] to 
+        # get the directory of the source code. They expect it to refer to the 
+        # setup.py script. 
+        sys_argv_0 = sys.argv[0] 
+        sys.argv[0] = setup_script 
+ 
+        try: 
+            super(_BuildMetaLegacyBackend, 
+                  self).run_setup(setup_script=setup_script) 
+        finally: 
+            # While PEP 517 frontends should be calling each hook in a fresh 
+            # subprocess according to the standard (and thus it should not be 
+            # strictly necessary to restore the old sys.path), we'll restore 
+            # the original path so that the path manipulation does not persist 
+            # within the hook after run_setup is called. 
+            sys.path[:] = sys_path 
+            sys.argv[0] = sys_argv_0 
+ 
+# The primary backend 
+_BACKEND = _BuildMetaBackend() 
+ 
+get_requires_for_build_wheel = _BACKEND.get_requires_for_build_wheel 
+get_requires_for_build_sdist = _BACKEND.get_requires_for_build_sdist 
+prepare_metadata_for_build_wheel = _BACKEND.prepare_metadata_for_build_wheel 
+build_wheel = _BACKEND.build_wheel 
+build_sdist = _BACKEND.build_sdist 
+ 
+ 
+# The legacy backend 
+__legacy__ = _BuildMetaLegacyBackend() 
diff --git a/contrib/python/setuptools/py2/setuptools/command/__init__.py b/contrib/python/setuptools/py2/setuptools/command/__init__.py
index 743f5588fa..e23f559da0 100644
--- a/contrib/python/setuptools/py2/setuptools/command/__init__.py
+++ b/contrib/python/setuptools/py2/setuptools/command/__init__.py
@@ -2,7 +2,7 @@ __all__ = [
     'alias', 'bdist_egg', 'bdist_rpm', 'build_ext', 'build_py', 'develop',
     'easy_install', 'egg_info', 'install', 'install_lib', 'rotate', 'saveopts',
     'sdist', 'setopt', 'test', 'install_egg_info', 'install_scripts',
-    'bdist_wininst', 'upload_docs', 'build_clib', 'dist_info',
+    'bdist_wininst', 'upload_docs', 'build_clib', 'dist_info', 
 ]
 
 from distutils.command.bdist import bdist
diff --git a/contrib/python/setuptools/py2/setuptools/command/alias.py b/contrib/python/setuptools/py2/setuptools/command/alias.py
index 4532b1cc0d..a3704d1b03 100644
--- a/contrib/python/setuptools/py2/setuptools/command/alias.py
+++ b/contrib/python/setuptools/py2/setuptools/command/alias.py
@@ -1,6 +1,6 @@
 from distutils.errors import DistutilsOptionError
 
-from setuptools.extern.six.moves import map
+from setuptools.extern.six.moves import map 
 
 from setuptools.command.setopt import edit_config, option_base, config_file
 
diff --git a/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py b/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py
index 98470f1715..953fea47d9 100644
--- a/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py
+++ b/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py
@@ -8,11 +8,11 @@ from distutils import log
 from types import CodeType
 import sys
 import os
-import re
+import re 
 import textwrap
 import marshal
 
-from setuptools.extern import six
+from setuptools.extern import six 
 
 from pkg_resources import get_build_platform, Distribution, ensure_directory
 from pkg_resources import EntryPoint
@@ -40,16 +40,16 @@ def strip_module(filename):
     return filename
 
 
-def sorted_walk(dir):
-    """Do os.walk in a reproducible way,
-    independent of indeterministic filesystem readdir order
-    """
-    for base, dirs, files in os.walk(dir):
-        dirs.sort()
-        files.sort()
-        yield base, dirs, files
-
-
+def sorted_walk(dir): 
+    """Do os.walk in a reproducible way, 
+    independent of indeterministic filesystem readdir order 
+    """ 
+    for base, dirs, files in os.walk(dir): 
+        dirs.sort() 
+        files.sort() 
+        yield base, dirs, files 
+ 
+ 
 def write_stub(resource, pyfile):
     _stub_template = textwrap.dedent("""
         def __bootstrap__():
@@ -243,28 +243,28 @@ class bdist_egg(Command):
         log.info("Removing .py files from temporary directory")
         for base, dirs, files in walk_egg(self.bdist_dir):
             for name in files:
-                path = os.path.join(base, name)
-
+                path = os.path.join(base, name) 
+ 
                 if name.endswith('.py'):
                     log.debug("Deleting %s", path)
                     os.unlink(path)
 
-                if base.endswith('__pycache__'):
-                    path_old = path
-
-                    pattern = r'(?P<name>.+)\.(?P<magic>[^.]+)\.pyc'
-                    m = re.match(pattern, name)
-                    path_new = os.path.join(
-                        base, os.pardir, m.group('name') + '.pyc')
-                    log.info(
-                        "Renaming file from [%s] to [%s]"
-                        % (path_old, path_new))
-                    try:
-                        os.remove(path_new)
-                    except OSError:
-                        pass
-                    os.rename(path_old, path_new)
-
+                if base.endswith('__pycache__'): 
+                    path_old = path 
+ 
+                    pattern = r'(?P<name>.+)\.(?P<magic>[^.]+)\.pyc' 
+                    m = re.match(pattern, name) 
+                    path_new = os.path.join( 
+                        base, os.pardir, m.group('name') + '.pyc') 
+                    log.info( 
+                        "Renaming file from [%s] to [%s]" 
+                        % (path_old, path_new)) 
+                    try: 
+                        os.remove(path_new) 
+                    except OSError: 
+                        pass 
+                    os.rename(path_old, path_new) 
+ 
     def zip_safe(self):
         safe = getattr(self.distribution, 'zip_safe', None)
         if safe is not None:
@@ -284,7 +284,7 @@ class bdist_egg(Command):
                 "or refer to a module" % (ep,)
             )
 
-        pyver = '{}.{}'.format(*sys.version_info)
+        pyver = '{}.{}'.format(*sys.version_info) 
         pkg = ep.module_name
         full = '.'.join(ep.attrs)
         base = ep.attrs[0]
@@ -330,7 +330,7 @@ class bdist_egg(Command):
         ext_outputs = []
 
         paths = {self.bdist_dir: ''}
-        for base, dirs, files in sorted_walk(self.bdist_dir):
+        for base, dirs, files in sorted_walk(self.bdist_dir): 
             for filename in files:
                 if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
                     all_outputs.append(paths[base] + filename)
@@ -357,7 +357,7 @@ NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())
 
 def walk_egg(egg_dir):
     """Walk an unpacked egg's contents, skipping the metadata directory"""
-    walker = sorted_walk(egg_dir)
+    walker = sorted_walk(egg_dir) 
     base, dirs, files = next(walker)
     if 'EGG-INFO' in dirs:
         dirs.remove('EGG-INFO')
@@ -411,12 +411,12 @@ def scan_module(egg_dir, base, name, stubs):
         return True  # Extension module
     pkg = base[len(egg_dir) + 1:].replace(os.sep, '.')
     module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
-    if six.PY2:
+    if six.PY2: 
         skip = 8  # skip magic & date
-    elif sys.version_info < (3, 7):
-        skip = 12  # skip magic & date & file size
+    elif sys.version_info < (3, 7): 
+        skip = 12  # skip magic & date & file size 
     else:
-        skip = 16  # skip magic & reserved? & date & file size
+        skip = 16  # skip magic & reserved? & date & file size 
     f = open(filename, 'rb')
     f.read(skip)
     code = marshal.load(f)
@@ -493,10 +493,10 @@ def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
     compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
     if not dry_run:
         z = zipfile.ZipFile(zip_filename, mode, compression=compression)
-        for dirname, dirs, files in sorted_walk(base_dir):
+        for dirname, dirs, files in sorted_walk(base_dir): 
             visit(z, dirname, files)
         z.close()
     else:
-        for dirname, dirs, files in sorted_walk(base_dir):
+        for dirname, dirs, files in sorted_walk(base_dir): 
             visit(None, dirname, files)
     return zip_filename
diff --git a/contrib/python/setuptools/py2/setuptools/command/build_ext.py b/contrib/python/setuptools/py2/setuptools/command/build_ext.py
index 1b51e040b4..ba15914080 100644
--- a/contrib/python/setuptools/py2/setuptools/command/build_ext.py
+++ b/contrib/python/setuptools/py2/setuptools/command/build_ext.py
@@ -9,21 +9,21 @@ from distutils.errors import DistutilsError
 from distutils import log
 
 from setuptools.extension import Library
-from setuptools.extern import six
-
-if six.PY2:
-    import imp
-
-    EXTENSION_SUFFIXES = [s for s, _, tp in imp.get_suffixes() if tp == imp.C_EXTENSION]
-else:
-    from importlib.machinery import EXTENSION_SUFFIXES
-
+from setuptools.extern import six 
+
+if six.PY2: 
+    import imp 
+ 
+    EXTENSION_SUFFIXES = [s for s, _, tp in imp.get_suffixes() if tp == imp.C_EXTENSION] 
+else: 
+    from importlib.machinery import EXTENSION_SUFFIXES 
+ 
 try:
     # Attempt to use Cython for building extensions, if available
     from Cython.Distutils.build_ext import build_ext as _build_ext
-    # Additionally, assert that the compiler module will load
-    # also. Ref #1229.
-    __import__('Cython.Compiler.Main')
+    # Additionally, assert that the compiler module will load 
+    # also. Ref #1229. 
+    __import__('Cython.Compiler.Main') 
 except ImportError:
     _build_ext = _du_build_ext
 
@@ -70,7 +70,7 @@ if_dl = lambda s: s if have_rtld else ''
 
 def get_abi3_suffix():
     """Return the file extension for an abi3-compliant Extension()"""
-    for suffix in EXTENSION_SUFFIXES:
+    for suffix in EXTENSION_SUFFIXES: 
         if '.abi3' in suffix:  # Unix
             return suffix
         elif suffix == '.pyd':  # Windows
@@ -113,12 +113,12 @@ class build_ext(_build_ext):
         if fullname in self.ext_map:
             ext = self.ext_map[fullname]
             use_abi3 = (
-                not six.PY2
+                not six.PY2 
                 and getattr(ext, 'py_limited_api')
                 and get_abi3_suffix()
             )
             if use_abi3:
-                so_ext = get_config_var('EXT_SUFFIX')
+                so_ext = get_config_var('EXT_SUFFIX') 
                 filename = filename[:-len(so_ext)]
                 filename = filename + get_abi3_suffix()
             if isinstance(ext, Library):
diff --git a/contrib/python/setuptools/py2/setuptools/command/build_py.py b/contrib/python/setuptools/py2/setuptools/command/build_py.py
index b0314fd413..788acf1884 100644
--- a/contrib/python/setuptools/py2/setuptools/command/build_py.py
+++ b/contrib/python/setuptools/py2/setuptools/command/build_py.py
@@ -8,8 +8,8 @@ import io
 import distutils.errors
 import itertools
 
-from setuptools.extern import six
-from setuptools.extern.six.moves import map, filter, filterfalse
+from setuptools.extern import six 
+from setuptools.extern.six.moves import map, filter, filterfalse 
 
 try:
     from setuptools.lib2to3_ex import Mixin2to3
diff --git a/contrib/python/setuptools/py2/setuptools/command/develop.py b/contrib/python/setuptools/py2/setuptools/command/develop.py
index b561924609..9f0883d8d3 100644
--- a/contrib/python/setuptools/py2/setuptools/command/develop.py
+++ b/contrib/python/setuptools/py2/setuptools/command/develop.py
@@ -5,16 +5,16 @@ import os
 import glob
 import io
 
-from setuptools.extern import six
+from setuptools.extern import six 
 
-import pkg_resources
+import pkg_resources 
 from setuptools.command.easy_install import easy_install
 from setuptools import namespaces
 import setuptools
 
-__metaclass__ = type
-
+__metaclass__ = type 
 
+ 
 class develop(namespaces.DevelopInstaller, easy_install):
     """Set up package for development"""
 
@@ -65,9 +65,9 @@ class develop(namespaces.DevelopInstaller, easy_install):
         if self.egg_path is None:
             self.egg_path = os.path.abspath(ei.egg_base)
 
-        target = pkg_resources.normalize_path(self.egg_base)
-        egg_path = pkg_resources.normalize_path(
-            os.path.join(self.install_dir, self.egg_path))
+        target = pkg_resources.normalize_path(self.egg_base) 
+        egg_path = pkg_resources.normalize_path( 
+            os.path.join(self.install_dir, self.egg_path)) 
         if egg_path != target:
             raise DistutilsOptionError(
                 "--egg-path must be a relative path from the install"
@@ -75,9 +75,9 @@ class develop(namespaces.DevelopInstaller, easy_install):
             )
 
         # Make a distribution for the package's source
-        self.dist = pkg_resources.Distribution(
+        self.dist = pkg_resources.Distribution( 
             target,
-            pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
+            pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)), 
             project_name=ei.egg_name
         )
 
@@ -97,25 +97,25 @@ class develop(namespaces.DevelopInstaller, easy_install):
         path_to_setup = egg_base.replace(os.sep, '/').rstrip('/')
         if path_to_setup != os.curdir:
             path_to_setup = '../' * (path_to_setup.count('/') + 1)
-        resolved = pkg_resources.normalize_path(
-            os.path.join(install_dir, egg_path, path_to_setup)
-        )
-        if resolved != pkg_resources.normalize_path(os.curdir):
+        resolved = pkg_resources.normalize_path( 
+            os.path.join(install_dir, egg_path, path_to_setup) 
+        ) 
+        if resolved != pkg_resources.normalize_path(os.curdir): 
             raise DistutilsOptionError(
                 "Can't get a consistent path to setup script from"
-                " installation directory", resolved,
-                pkg_resources.normalize_path(os.curdir))
+                " installation directory", resolved, 
+                pkg_resources.normalize_path(os.curdir)) 
         return path_to_setup
 
     def install_for_development(self):
-        if not six.PY2 and getattr(self.distribution, 'use_2to3', False):
+        if not six.PY2 and getattr(self.distribution, 'use_2to3', False): 
             # If we run 2to3 we can not do this inplace:
 
             # Ensure metadata is up-to-date
             self.reinitialize_command('build_py', inplace=0)
             self.run_command('build_py')
             bpy_cmd = self.get_finalized_command("build_py")
-            build_path = pkg_resources.normalize_path(bpy_cmd.build_lib)
+            build_path = pkg_resources.normalize_path(bpy_cmd.build_lib) 
 
             # Build extensions
             self.reinitialize_command('egg_info', egg_base=build_path)
@@ -129,8 +129,8 @@ class develop(namespaces.DevelopInstaller, easy_install):
             self.egg_path = build_path
             self.dist.location = build_path
             # XXX
-            self.dist._provider = pkg_resources.PathMetadata(
-                build_path, ei_cmd.egg_info)
+            self.dist._provider = pkg_resources.PathMetadata( 
+                build_path, ei_cmd.egg_info) 
         else:
             # Without 2to3 inplace works fine:
             self.run_command('egg_info')
@@ -196,13 +196,13 @@ class develop(namespaces.DevelopInstaller, easy_install):
         return easy_install.install_wrapper_scripts(self, dist)
 
 
-class VersionlessRequirement:
+class VersionlessRequirement: 
     """
     Adapt a pkg_resources.Distribution to simply return the project
     name as the 'requirement' so that scripts will work across
     multiple versions.
 
-    >>> from pkg_resources import Distribution
+    >>> from pkg_resources import Distribution 
     >>> dist = Distribution(project_name='foo', version='1.0')
     >>> str(dist.as_requirement())
     'foo==1.0'
diff --git a/contrib/python/setuptools/py2/setuptools/command/dist_info.py b/contrib/python/setuptools/py2/setuptools/command/dist_info.py
index c45258fa03..1426588fe1 100644
--- a/contrib/python/setuptools/py2/setuptools/command/dist_info.py
+++ b/contrib/python/setuptools/py2/setuptools/command/dist_info.py
@@ -1,36 +1,36 @@
-"""
-Create a dist_info directory
-As defined in the wheel specification
-"""
-
-import os
-
-from distutils.core import Command
-from distutils import log
-
-
-class dist_info(Command):
-
-    description = 'create a .dist-info directory'
-
-    user_options = [
-        ('egg-base=', 'e', "directory containing .egg-info directories"
-                           " (default: top of the source tree)"),
-    ]
-
-    def initialize_options(self):
-        self.egg_base = None
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        egg_info = self.get_finalized_command('egg_info')
-        egg_info.egg_base = self.egg_base
-        egg_info.finalize_options()
-        egg_info.run()
-        dist_info_dir = egg_info.egg_info[:-len('.egg-info')] + '.dist-info'
-        log.info("creating '{}'".format(os.path.abspath(dist_info_dir)))
-
-        bdist_wheel = self.get_finalized_command('bdist_wheel')
-        bdist_wheel.egg2dist(egg_info.egg_info, dist_info_dir)
+""" 
+Create a dist_info directory 
+As defined in the wheel specification 
+""" 
+ 
+import os 
+ 
+from distutils.core import Command 
+from distutils import log 
+ 
+ 
+class dist_info(Command): 
+ 
+    description = 'create a .dist-info directory' 
+ 
+    user_options = [ 
+        ('egg-base=', 'e', "directory containing .egg-info directories" 
+                           " (default: top of the source tree)"), 
+    ] 
+ 
+    def initialize_options(self): 
+        self.egg_base = None 
+ 
+    def finalize_options(self): 
+        pass 
+ 
+    def run(self): 
+        egg_info = self.get_finalized_command('egg_info') 
+        egg_info.egg_base = self.egg_base 
+        egg_info.finalize_options() 
+        egg_info.run() 
+        dist_info_dir = egg_info.egg_info[:-len('.egg-info')] + '.dist-info' 
+        log.info("creating '{}'".format(os.path.abspath(dist_info_dir))) 
+ 
+        bdist_wheel = self.get_finalized_command('bdist_wheel') 
+        bdist_wheel.egg2dist(egg_info.egg_info, dist_info_dir) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/easy_install.py b/contrib/python/setuptools/py2/setuptools/command/easy_install.py
index 426301d6f3..85a97b4682 100644
--- a/contrib/python/setuptools/py2/setuptools/command/easy_install.py
+++ b/contrib/python/setuptools/py2/setuptools/command/easy_install.py
@@ -41,13 +41,13 @@ import shlex
 import io
 
 
-from sysconfig import get_config_vars, get_path
-
-from setuptools import SetuptoolsDeprecationWarning
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import configparser, map
-
+from sysconfig import get_config_vars, get_path 
+ 
+from setuptools import SetuptoolsDeprecationWarning 
+ 
+from setuptools.extern import six 
+from setuptools.extern.six.moves import configparser, map 
+ 
 from setuptools import Command
 from setuptools.sandbox import run_setup
 from setuptools.py27compat import rmtree_safe
@@ -57,17 +57,17 @@ from setuptools.package_index import (
     PackageIndex, parse_requirement_arg, URL_SCHEME,
 )
 from setuptools.command import bdist_egg, egg_info
-from setuptools.wheel import Wheel
+from setuptools.wheel import Wheel 
 from pkg_resources import (
     yield_lines, normalize_path, resource_string, ensure_directory,
     get_distribution, find_distributions, Environment, Requirement,
     Distribution, PathMetadata, EggMetadata, WorkingSet, DistributionNotFound,
     VersionConflict, DEVELOP_DIST,
 )
-import pkg_resources.py31compat
-
-__metaclass__ = type
+import pkg_resources.py31compat 
 
+__metaclass__ = type 
+ 
 # Turn on PEP440Warnings
 warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)
 
@@ -99,7 +99,7 @@ def samefile(p1, p2):
 
 if six.PY2:
 
-    def _to_bytes(s):
+    def _to_bytes(s): 
         return s
 
     def isascii(s):
@@ -110,8 +110,8 @@ if six.PY2:
             return False
 else:
 
-    def _to_bytes(s):
-        return s.encode('utf8')
+    def _to_bytes(s): 
+        return s.encode('utf8') 
 
     def isascii(s):
         try:
@@ -241,7 +241,7 @@ class easy_install(Command):
         """
         Render the Setuptools version and installation details, then exit.
         """
-        ver = '{}.{}'.format(*sys.version_info)
+        ver = '{}.{}'.format(*sys.version_info) 
         dist = get_distribution('setuptools')
         tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})'
         print(tmpl.format(**locals()))
@@ -325,7 +325,7 @@ class easy_install(Command):
                     self.all_site_dirs.append(normalize_path(d))
         if not self.editable:
             self.check_site_dir()
-        self.index_url = self.index_url or "https://pypi.org/simple/"
+        self.index_url = self.index_url or "https://pypi.org/simple/" 
         self.shadow_path = self.all_site_dirs[:]
         for path_item in self.install_dir, normalize_path(self.script_dir):
             if path_item not in self.shadow_path:
@@ -410,13 +410,13 @@ class easy_install(Command):
         ]
         self._expand_attrs(dirs)
 
-    def run(self, show_deprecation=True):
-        if show_deprecation:
-            self.announce(
-                "WARNING: The easy_install command is deprecated "
-                "and will be removed in a future version."
-                , log.WARN,
-            )
+    def run(self, show_deprecation=True): 
+        if show_deprecation: 
+            self.announce( 
+                "WARNING: The easy_install command is deprecated " 
+                "and will be removed in a future version." 
+                , log.WARN, 
+            ) 
         if self.verbose != self.distribution.verbose:
             log.set_verbosity(self.verbose)
         try:
@@ -487,7 +487,7 @@ class easy_install(Command):
         else:
             self.pth_file = None
 
-        if instdir not in map(normalize_path, _pythonpath()):
+        if instdir not in map(normalize_path, _pythonpath()): 
             # only PYTHONPATH dirs need a site.py, so pretend it's there
             self.sitepy_installed = True
         elif self.multi_version and not os.path.exists(pth_file):
@@ -557,7 +557,7 @@ class easy_install(Command):
             if ok_exists:
                 os.unlink(ok_file)
             dirname = os.path.dirname(ok_file)
-            pkg_resources.py31compat.makedirs(dirname, exist_ok=True)
+            pkg_resources.py31compat.makedirs(dirname, exist_ok=True) 
             f = open(pth_file, 'w')
         except (OSError, IOError):
             self.cant_write_to_target()
@@ -641,7 +641,7 @@ class easy_install(Command):
 
     @contextlib.contextmanager
     def _tmpdir(self):
-        tmpdir = tempfile.mkdtemp(prefix=u"easy_install-")
+        tmpdir = tempfile.mkdtemp(prefix=u"easy_install-") 
         try:
             # cast to str as workaround for #709 and #710 and #712
             yield str(tmpdir)
@@ -814,7 +814,7 @@ class easy_install(Command):
         if is_script:
             body = self._load_template(dev_path) % locals()
             script_text = ScriptWriter.get_header(script_text) + body
-        self.write_script(script_name, _to_bytes(script_text), 'b')
+        self.write_script(script_name, _to_bytes(script_text), 'b') 
 
     @staticmethod
     def _load_template(dev_path):
@@ -840,16 +840,16 @@ class easy_install(Command):
         target = os.path.join(self.script_dir, script_name)
         self.add_output(target)
 
-        if self.dry_run:
-            return
-
+        if self.dry_run: 
+            return 
+ 
         mask = current_umask()
-        ensure_directory(target)
-        if os.path.exists(target):
-            os.unlink(target)
-        with open(target, "w" + mode) as f:
-            f.write(contents)
-        chmod(target, 0o777 - mask)
+        ensure_directory(target) 
+        if os.path.exists(target): 
+            os.unlink(target) 
+        with open(target, "w" + mode) as f: 
+            f.write(contents) 
+        chmod(target, 0o777 - mask) 
 
     def install_eggs(self, spec, dist_filename, tmpdir):
         # .egg dirs or files are already built, so just return them
@@ -857,8 +857,8 @@ class easy_install(Command):
             return [self.install_egg(dist_filename, tmpdir)]
         elif dist_filename.lower().endswith('.exe'):
             return [self.install_exe(dist_filename, tmpdir)]
-        elif dist_filename.lower().endswith('.whl'):
-            return [self.install_wheel(dist_filename, tmpdir)]
+        elif dist_filename.lower().endswith('.whl'): 
+            return [self.install_wheel(dist_filename, tmpdir)] 
 
         # Anything else, try to extract and build
         setup_base = tmpdir
@@ -1055,35 +1055,35 @@ class easy_install(Command):
                     f.write('\n'.join(locals()[name]) + '\n')
                     f.close()
 
-    def install_wheel(self, wheel_path, tmpdir):
-        wheel = Wheel(wheel_path)
-        assert wheel.is_compatible()
-        destination = os.path.join(self.install_dir, wheel.egg_name())
-        destination = os.path.abspath(destination)
-        if not self.dry_run:
-            ensure_directory(destination)
-        if os.path.isdir(destination) and not os.path.islink(destination):
-            dir_util.remove_tree(destination, dry_run=self.dry_run)
-        elif os.path.exists(destination):
-            self.execute(
-                os.unlink,
-                (destination,),
-                "Removing " + destination,
-            )
-        try:
-            self.execute(
-                wheel.install_as_egg,
-                (destination,),
-                ("Installing %s to %s") % (
-                    os.path.basename(wheel_path),
-                    os.path.dirname(destination)
-                ),
-            )
-        finally:
-            update_dist_caches(destination, fix_zipimporter_caches=False)
-        self.add_output(destination)
-        return self.egg_distribution(destination)
-
+    def install_wheel(self, wheel_path, tmpdir): 
+        wheel = Wheel(wheel_path) 
+        assert wheel.is_compatible() 
+        destination = os.path.join(self.install_dir, wheel.egg_name()) 
+        destination = os.path.abspath(destination) 
+        if not self.dry_run: 
+            ensure_directory(destination) 
+        if os.path.isdir(destination) and not os.path.islink(destination): 
+            dir_util.remove_tree(destination, dry_run=self.dry_run) 
+        elif os.path.exists(destination): 
+            self.execute( 
+                os.unlink, 
+                (destination,), 
+                "Removing " + destination, 
+            ) 
+        try: 
+            self.execute( 
+                wheel.install_as_egg, 
+                (destination,), 
+                ("Installing %s to %s") % ( 
+                    os.path.basename(wheel_path), 
+                    os.path.dirname(destination) 
+                ), 
+            ) 
+        finally: 
+            update_dist_caches(destination, fix_zipimporter_caches=False) 
+        self.add_output(destination) 
+        return self.egg_distribution(destination) 
+ 
     __mv_warning = textwrap.dedent("""
         Because this distribution was installed --multi-version, before you can
         import modules from this package in an application, you will need to
@@ -1186,7 +1186,7 @@ class easy_install(Command):
         # to the setup.cfg file.
         ei_opts = self.distribution.get_option_dict('easy_install').copy()
         fetch_directives = (
-            'find_links', 'site_dirs', 'index_url', 'optimize', 'allow_hosts',
+            'find_links', 'site_dirs', 'index_url', 'optimize', 'allow_hosts', 
         )
         fetch_options = {}
         for key, val in ei_opts.items():
@@ -1390,21 +1390,21 @@ class easy_install(Command):
                 setattr(self, attr, val)
 
 
-def _pythonpath():
-    items = os.environ.get('PYTHONPATH', '').split(os.pathsep)
-    return filter(None, items)
-
-
+def _pythonpath(): 
+    items = os.environ.get('PYTHONPATH', '').split(os.pathsep) 
+    return filter(None, items) 
+ 
+ 
 def get_site_dirs():
-    """
-    Return a list of 'site' dirs
-    """
-
-    sitedirs = []
-
-    # start with PYTHONPATH
-    sitedirs.extend(_pythonpath())
-
+    """ 
+    Return a list of 'site' dirs 
+    """ 
+ 
+    sitedirs = [] 
+ 
+    # start with PYTHONPATH 
+    sitedirs.extend(_pythonpath()) 
+ 
     prefixes = [sys.prefix]
     if sys.exec_prefix != sys.prefix:
         prefixes.append(sys.exec_prefix)
@@ -1417,7 +1417,7 @@ def get_site_dirs():
                     os.path.join(
                         prefix,
                         "lib",
-                        "python{}.{}".format(*sys.version_info),
+                        "python{}.{}".format(*sys.version_info), 
                         "site-packages",
                     ),
                     os.path.join(prefix, "lib", "site-python"),
@@ -1438,7 +1438,7 @@ def get_site_dirs():
                             home,
                             'Library',
                             'Python',
-                            '{}.{}'.format(*sys.version_info),
+                            '{}.{}'.format(*sys.version_info), 
                             'site-packages',
                         )
                         sitedirs.append(home_sp)
@@ -1567,7 +1567,7 @@ def get_exe_prefixes(exe_filename):
                 continue
             if parts[0].upper() in ('PURELIB', 'PLATLIB'):
                 contents = z.read(name)
-                if not six.PY2:
+                if not six.PY2: 
                     contents = contents.decode()
                 for pth in yield_lines(contents):
                     pth = pth.strip().replace('\\', '/')
@@ -1861,7 +1861,7 @@ def _update_zipimporter_cache(normalized_path, cache, updater=None):
         #    get/del patterns instead. For more detailed information see the
         #    following links:
         #      https://github.com/pypa/setuptools/issues/202#issuecomment-202913420
-        #      http://bit.ly/2h9itJX
+        #      http://bit.ly/2h9itJX 
         old_entry = cache[p]
         del cache[p]
         new_entry = updater and updater(p, old_entry)
@@ -2060,7 +2060,7 @@ class WindowsCommandSpec(CommandSpec):
     split_args = dict(posix=False)
 
 
-class ScriptWriter:
+class ScriptWriter: 
     """
     Encapsulates behavior around writing entry point scripts for console and
     gui apps.
@@ -2085,7 +2085,7 @@ class ScriptWriter:
     @classmethod
     def get_script_args(cls, dist, executable=None, wininst=False):
         # for backward compatibility
-        warnings.warn("Use get_args", EasyInstallDeprecationWarning)
+        warnings.warn("Use get_args", EasyInstallDeprecationWarning) 
         writer = (WindowsScriptWriter if wininst else ScriptWriter).best()
         header = cls.get_script_header("", executable, wininst)
         return writer.get_args(dist, header)
@@ -2093,10 +2093,10 @@ class ScriptWriter:
     @classmethod
     def get_script_header(cls, script_text, executable=None, wininst=False):
         # for backward compatibility
-        warnings.warn("Use get_header", EasyInstallDeprecationWarning, stacklevel=2)
+        warnings.warn("Use get_header", EasyInstallDeprecationWarning, stacklevel=2) 
         if wininst:
             executable = "python.exe"
-        return cls.get_header(script_text, executable)
+        return cls.get_header(script_text, executable) 
 
     @classmethod
     def get_args(cls, dist, header=None):
@@ -2128,7 +2128,7 @@ class ScriptWriter:
     @classmethod
     def get_writer(cls, force_windows):
         # for backward compatibility
-        warnings.warn("Use best", EasyInstallDeprecationWarning)
+        warnings.warn("Use best", EasyInstallDeprecationWarning) 
         return WindowsScriptWriter.best() if force_windows else cls.best()
 
     @classmethod
@@ -2160,7 +2160,7 @@ class WindowsScriptWriter(ScriptWriter):
     @classmethod
     def get_writer(cls):
         # for backward compatibility
-        warnings.warn("Use best", EasyInstallDeprecationWarning)
+        warnings.warn("Use best", EasyInstallDeprecationWarning) 
         return cls.best()
 
     @classmethod
@@ -2341,7 +2341,7 @@ def _patch_usage():
         yield
     finally:
         distutils.core.gen_usage = saved
-
-class EasyInstallDeprecationWarning(SetuptoolsDeprecationWarning):
-    """Class for warning about deprecations in EasyInstall in SetupTools. Not ignored by default, unlike DeprecationWarning."""
-    
+ 
+class EasyInstallDeprecationWarning(SetuptoolsDeprecationWarning): 
+    """Class for warning about deprecations in EasyInstall in SetupTools. Not ignored by default, unlike DeprecationWarning.""" 
+     
diff --git a/contrib/python/setuptools/py2/setuptools/command/egg_info.py b/contrib/python/setuptools/py2/setuptools/command/egg_info.py
index a5c5a2fc19..674a3006d5 100644
--- a/contrib/python/setuptools/py2/setuptools/command/egg_info.py
+++ b/contrib/python/setuptools/py2/setuptools/command/egg_info.py
@@ -16,8 +16,8 @@ import warnings
 import time
 import collections
 
-from setuptools.extern import six
-from setuptools.extern.six.moves import map
+from setuptools.extern import six 
+from setuptools.extern.six.moves import map 
 
 from setuptools import Command
 from setuptools.command.sdist import sdist
@@ -30,8 +30,8 @@ from pkg_resources import (
 import setuptools.unicode_utils as unicode_utils
 from setuptools.glob import glob
 
-from setuptools.extern import packaging
-from setuptools import SetuptoolsDeprecationWarning
+from setuptools.extern import packaging 
+from setuptools import SetuptoolsDeprecationWarning 
 
 def translate_pattern(glob):
     """
@@ -112,37 +112,37 @@ def translate_pattern(glob):
         if not last_chunk:
             pat += sep
 
-    pat += r'\Z'
-    return re.compile(pat, flags=re.MULTILINE|re.DOTALL)
-
-
-class InfoCommon:
-    tag_build = None
-    tag_date = None
-
-    @property
-    def name(self):
-        return safe_name(self.distribution.get_name())
-
-    def tagged_version(self):
-        version = self.distribution.get_version()
-        # egg_info may be called more than once for a distribution,
-        # in which case the version string already contains all tags.
-        if self.vtags and version.endswith(self.vtags):
-            return safe_version(version)
-        return safe_version(version + self.vtags)
-
-    def tags(self):
-        version = ''
-        if self.tag_build:
-            version += self.tag_build
-        if self.tag_date:
-            version += time.strftime("-%Y%m%d")
-        return version
-    vtags = property(tags)
-
-
-class egg_info(InfoCommon, Command):
+    pat += r'\Z' 
+    return re.compile(pat, flags=re.MULTILINE|re.DOTALL) 
+
+
+class InfoCommon: 
+    tag_build = None 
+    tag_date = None 
+ 
+    @property 
+    def name(self): 
+        return safe_name(self.distribution.get_name()) 
+ 
+    def tagged_version(self): 
+        version = self.distribution.get_version() 
+        # egg_info may be called more than once for a distribution, 
+        # in which case the version string already contains all tags. 
+        if self.vtags and version.endswith(self.vtags): 
+            return safe_version(version) 
+        return safe_version(version + self.vtags) 
+ 
+    def tags(self): 
+        version = '' 
+        if self.tag_build: 
+            version += self.tag_build 
+        if self.tag_date: 
+            version += time.strftime("-%Y%m%d") 
+        return version 
+    vtags = property(tags) 
+ 
+ 
+class egg_info(InfoCommon, Command): 
     description = "create a distribution's .egg-info directory"
 
     user_options = [
@@ -159,9 +159,9 @@ class egg_info(InfoCommon, Command):
     }
 
     def initialize_options(self):
-        self.egg_base = None
+        self.egg_base = None 
         self.egg_name = None
-        self.egg_info = None
+        self.egg_info = None 
         self.egg_version = None
         self.broken_egg_info = False
 
@@ -183,7 +183,7 @@ class egg_info(InfoCommon, Command):
         build tag. Install build keys in a deterministic order
         to avoid arbitrary reordering on subsequent builds.
         """
-        egg_info = collections.OrderedDict()
+        egg_info = collections.OrderedDict() 
         # follow the order these keys would have been added
         # when PYTHONHASHSEED=0
         egg_info['tag_build'] = self.tags()
@@ -191,11 +191,11 @@ class egg_info(InfoCommon, Command):
         edit_config(filename, dict(egg_info=egg_info))
 
     def finalize_options(self):
-        # Note: we need to capture the current value returned
-        # by `self.tagged_version()`, so we can later update
-        # `self.distribution.metadata.version` without
-        # repercussions.
-        self.egg_name = self.name
+        # Note: we need to capture the current value returned 
+        # by `self.tagged_version()`, so we can later update 
+        # `self.distribution.metadata.version` without 
+        # repercussions. 
+        self.egg_name = self.name 
         self.egg_version = self.tagged_version()
         parsed_version = parse_version(self.egg_version)
 
@@ -266,7 +266,7 @@ class egg_info(InfoCommon, Command):
         to the file.
         """
         log.info("writing %s to %s", what, filename)
-        if not six.PY2:
+        if not six.PY2: 
             data = data.encode("utf-8")
         if not self.dry_run:
             f = open(filename, 'wb')
@@ -281,7 +281,7 @@ class egg_info(InfoCommon, Command):
 
     def run(self):
         self.mkpath(self.egg_info)
-        os.utime(self.egg_info, None)
+        os.utime(self.egg_info, None) 
         installer = self.distribution.fetch_build_egg
         for ep in iter_entry_points('egg_info.writers'):
             ep.require(installer=installer)
@@ -568,7 +568,7 @@ class manifest_maker(sdist):
 
     def add_defaults(self):
         sdist.add_defaults(self)
-        self.check_license()
+        self.check_license() 
         self.filelist.append(self.template)
         self.filelist.append(self.manifest)
         rcfiles = list(walk_revctrl())
@@ -576,12 +576,12 @@ class manifest_maker(sdist):
             self.filelist.extend(rcfiles)
         elif os.path.exists(self.manifest):
             self.read_manifest()
-
-        if os.path.exists("setup.py"):
-            # setup.py should be included by default, even if it's not
-            # the script called to create the sdist
-            self.filelist.append("setup.py")
-
+ 
+        if os.path.exists("setup.py"): 
+            # setup.py should be included by default, even if it's not 
+            # the script called to create the sdist 
+            self.filelist.append("setup.py") 
+ 
         ei_cmd = self.get_finalized_command('egg_info')
         self.filelist.graft(ei_cmd.egg_info)
 
@@ -614,7 +614,7 @@ def write_pkg_info(cmd, basename, filename):
         metadata = cmd.distribution.metadata
         metadata.version, oldver = cmd.egg_version, metadata.version
         metadata.name, oldname = cmd.egg_name, metadata.name
-
+ 
         try:
             # write unescaped data to PKG-INFO, so older pkg_resources
             # can still parse it
@@ -654,7 +654,7 @@ def write_requirements(cmd, basename, filename):
 
 
 def write_setup_requirements(cmd, basename, filename):
-    data = io.StringIO()
+    data = io.StringIO() 
     _write_requirements(data, cmd.distribution.setup_requires)
     cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())
 
@@ -703,7 +703,7 @@ def get_pkg_info_revision():
     Get a -r### off of PKG-INFO Version in case this is an sdist of
     a subversion revision.
     """
-    warnings.warn("get_pkg_info_revision is deprecated.", EggInfoDeprecationWarning)
+    warnings.warn("get_pkg_info_revision is deprecated.", EggInfoDeprecationWarning) 
     if os.path.exists('PKG-INFO'):
         with io.open('PKG-INFO') as f:
             for line in f:
@@ -711,7 +711,7 @@ def get_pkg_info_revision():
                 if match:
                     return int(match.group(1))
     return 0
-
-
-class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning):
-    """Class for warning about deprecations in eggInfo in setupTools. Not ignored by default, unlike DeprecationWarning."""
+ 
+ 
+class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning): 
+    """Class for warning about deprecations in eggInfo in setupTools. Not ignored by default, unlike DeprecationWarning.""" 
diff --git a/contrib/python/setuptools/py2/setuptools/command/install.py b/contrib/python/setuptools/py2/setuptools/command/install.py
index 72b9a3e424..7d9bbff0bf 100644
--- a/contrib/python/setuptools/py2/setuptools/command/install.py
+++ b/contrib/python/setuptools/py2/setuptools/command/install.py
@@ -114,7 +114,7 @@ class install(orig.install):
             args.insert(0, setuptools.bootstrap_install_from)
 
         cmd.args = args
-        cmd.run(show_deprecation=False)
+        cmd.run(show_deprecation=False) 
         setuptools.bootstrap_install_from = None
 
 
diff --git a/contrib/python/setuptools/py2/setuptools/command/install_lib.py b/contrib/python/setuptools/py2/setuptools/command/install_lib.py
index 07d6593309..6fd83e9c1c 100644
--- a/contrib/python/setuptools/py2/setuptools/command/install_lib.py
+++ b/contrib/python/setuptools/py2/setuptools/command/install_lib.py
@@ -1,5 +1,5 @@
 import os
-import sys
+import sys 
 from itertools import product, starmap
 import distutils.command.install_lib as orig
 
@@ -74,10 +74,10 @@ class install_lib(orig.install_lib):
         yield '__init__.pyc'
         yield '__init__.pyo'
 
-        if not hasattr(sys, 'implementation'):
+        if not hasattr(sys, 'implementation'): 
             return
 
-        base = os.path.join('__pycache__', '__init__.' + sys.implementation.cache_tag)
+        base = os.path.join('__pycache__', '__init__.' + sys.implementation.cache_tag) 
         yield base + '.pyc'
         yield base + '.pyo'
         yield base + '.opt-1.pyc'
diff --git a/contrib/python/setuptools/py2/setuptools/command/py36compat.py b/contrib/python/setuptools/py2/setuptools/command/py36compat.py
index 61063e7542..9a13ae80f7 100644
--- a/contrib/python/setuptools/py2/setuptools/command/py36compat.py
+++ b/contrib/python/setuptools/py2/setuptools/command/py36compat.py
@@ -3,7 +3,7 @@ from glob import glob
 from distutils.util import convert_path
 from distutils.command import sdist
 
-from setuptools.extern.six.moves import filter
+from setuptools.extern.six.moves import filter 
 
 
 class sdist_add_defaults:
diff --git a/contrib/python/setuptools/py2/setuptools/command/register.py b/contrib/python/setuptools/py2/setuptools/command/register.py
index b8266b9a60..531c5bb813 100644
--- a/contrib/python/setuptools/py2/setuptools/command/register.py
+++ b/contrib/python/setuptools/py2/setuptools/command/register.py
@@ -1,18 +1,18 @@
-from distutils import log
+from distutils import log 
 import distutils.command.register as orig
 
-from setuptools.errors import RemovedCommandError
-
+from setuptools.errors import RemovedCommandError 
 
+ 
 class register(orig.register):
-    """Formerly used to register packages on PyPI."""
+    """Formerly used to register packages on PyPI.""" 
 
     def run(self):
-        msg = (
-            "The register command has been removed, use twine to upload "
-            + "instead (https://pypi.org/p/twine)"
-        )
-
-        self.announce("ERROR: " + msg, log.ERROR)
-
-        raise RemovedCommandError(msg)
+        msg = ( 
+            "The register command has been removed, use twine to upload " 
+            + "instead (https://pypi.org/p/twine)" 
+        ) 
+ 
+        self.announce("ERROR: " + msg, log.ERROR) 
+ 
+        raise RemovedCommandError(msg) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/rotate.py b/contrib/python/setuptools/py2/setuptools/command/rotate.py
index b89353f529..5c970106e6 100644
--- a/contrib/python/setuptools/py2/setuptools/command/rotate.py
+++ b/contrib/python/setuptools/py2/setuptools/command/rotate.py
@@ -4,7 +4,7 @@ from distutils.errors import DistutilsOptionError
 import os
 import shutil
 
-from setuptools.extern import six
+from setuptools.extern import six 
 
 from setuptools import Command
 
diff --git a/contrib/python/setuptools/py2/setuptools/command/sdist.py b/contrib/python/setuptools/py2/setuptools/command/sdist.py
index 8c3438eaa6..c7021b3989 100644
--- a/contrib/python/setuptools/py2/setuptools/command/sdist.py
+++ b/contrib/python/setuptools/py2/setuptools/command/sdist.py
@@ -5,7 +5,7 @@ import sys
 import io
 import contextlib
 
-from setuptools.extern import six, ordered_set
+from setuptools.extern import six, ordered_set 
 
 from .py36compat import sdist_add_defaults
 
@@ -37,8 +37,8 @@ class sdist(sdist_add_defaults, orig.sdist):
 
     negative_opt = {}
 
-    README_EXTENSIONS = ['', '.rst', '.txt', '.md']
-    READMES = tuple('README{0}'.format(ext) for ext in README_EXTENSIONS)
+    README_EXTENSIONS = ['', '.rst', '.txt', '.md'] 
+    READMES = tuple('README{0}'.format(ext) for ext in README_EXTENSIONS) 
 
     def run(self):
         self.run_command('egg_info')
@@ -121,41 +121,41 @@ class sdist(sdist_add_defaults, orig.sdist):
     if has_leaky_handle:
         read_template = __read_template_hack
 
-    def _add_defaults_optional(self):
-        if six.PY2:
-            sdist_add_defaults._add_defaults_optional(self)
-        else:
-            super()._add_defaults_optional()
-        if os.path.isfile('pyproject.toml'):
-            self.filelist.append('pyproject.toml')
-
+    def _add_defaults_optional(self): 
+        if six.PY2: 
+            sdist_add_defaults._add_defaults_optional(self) 
+        else: 
+            super()._add_defaults_optional() 
+        if os.path.isfile('pyproject.toml'): 
+            self.filelist.append('pyproject.toml') 
+ 
     def _add_defaults_python(self):
         """getting python files"""
         if self.distribution.has_pure_modules():
             build_py = self.get_finalized_command('build_py')
             self.filelist.extend(build_py.get_source_files())
-            self._add_data_files(self._safe_data_files(build_py))
-
-    def _safe_data_files(self, build_py):
-        """
-        Extracting data_files from build_py is known to cause
-        infinite recursion errors when `include_package_data`
-        is enabled, so suppress it in that case.
-        """
-        if self.distribution.include_package_data:
-            return ()
-        return build_py.data_files
-
-    def _add_data_files(self, data_files):
-        """
-        Add data files as found in build_py.data_files.
-        """
-        self.filelist.extend(
-            os.path.join(src_dir, name)
-            for _, src_dir, _, filenames in data_files
-            for name in filenames
-        )
-
+            self._add_data_files(self._safe_data_files(build_py)) 
+
+    def _safe_data_files(self, build_py): 
+        """ 
+        Extracting data_files from build_py is known to cause 
+        infinite recursion errors when `include_package_data` 
+        is enabled, so suppress it in that case. 
+        """ 
+        if self.distribution.include_package_data: 
+            return () 
+        return build_py.data_files 
+ 
+    def _add_data_files(self, data_files): 
+        """ 
+        Add data files as found in build_py.data_files. 
+        """ 
+        self.filelist.extend( 
+            os.path.join(src_dir, name) 
+            for _, src_dir, _, filenames in data_files 
+            for name in filenames 
+        ) 
+ 
     def _add_defaults_data_files(self):
         try:
             if six.PY2:
@@ -207,7 +207,7 @@ class sdist(sdist_add_defaults, orig.sdist):
         manifest = open(self.manifest, 'rb')
         for line in manifest:
             # The manifest must contain UTF-8. See #303.
-            if not six.PY2:
+            if not six.PY2: 
                 try:
                     line = line.decode('UTF-8')
                 except UnicodeDecodeError:
@@ -219,34 +219,34 @@ class sdist(sdist_add_defaults, orig.sdist):
                 continue
             self.filelist.append(line)
         manifest.close()
-
-    def check_license(self):
-        """Checks if license_file' or 'license_files' is configured and adds any
-        valid paths to 'self.filelist'.
-        """
-
-        files = ordered_set.OrderedSet()
-
-        opts = self.distribution.get_option_dict('metadata')
-
-        # ignore the source of the value
-        _, license_file = opts.get('license_file', (None, None))
-
-        if license_file is None:
-            log.debug("'license_file' option was not specified")
-        else:
-            files.add(license_file)
-
-        try:
-            files.update(self.distribution.metadata.license_files)
-        except TypeError:
-            log.warn("warning: 'license_files' option is malformed")
-
-        for f in files:
-            if not os.path.exists(f):
-                log.warn(
-                    "warning: Failed to find the configured license file '%s'",
-                    f)
-                files.remove(f)
-
-        self.filelist.extend(files)
+ 
+    def check_license(self): 
+        """Checks if license_file' or 'license_files' is configured and adds any 
+        valid paths to 'self.filelist'. 
+        """ 
+ 
+        files = ordered_set.OrderedSet() 
+ 
+        opts = self.distribution.get_option_dict('metadata') 
+ 
+        # ignore the source of the value 
+        _, license_file = opts.get('license_file', (None, None)) 
+ 
+        if license_file is None: 
+            log.debug("'license_file' option was not specified") 
+        else: 
+            files.add(license_file) 
+ 
+        try: 
+            files.update(self.distribution.metadata.license_files) 
+        except TypeError: 
+            log.warn("warning: 'license_files' option is malformed") 
+ 
+        for f in files: 
+            if not os.path.exists(f): 
+                log.warn( 
+                    "warning: Failed to find the configured license file '%s'", 
+                    f) 
+                files.remove(f) 
+ 
+        self.filelist.extend(files) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/setopt.py b/contrib/python/setuptools/py2/setuptools/command/setopt.py
index 7e57cc0262..e87690d790 100644
--- a/contrib/python/setuptools/py2/setuptools/command/setopt.py
+++ b/contrib/python/setuptools/py2/setuptools/command/setopt.py
@@ -4,7 +4,7 @@ from distutils.errors import DistutilsOptionError
 import distutils
 import os
 
-from setuptools.extern.six.moves import configparser
+from setuptools.extern.six.moves import configparser 
 
 from setuptools import Command
 
diff --git a/contrib/python/setuptools/py2/setuptools/command/test.py b/contrib/python/setuptools/py2/setuptools/command/test.py
index f6470e9c34..98d4da67c4 100644
--- a/contrib/python/setuptools/py2/setuptools/command/test.py
+++ b/contrib/python/setuptools/py2/setuptools/command/test.py
@@ -3,29 +3,29 @@ import operator
 import sys
 import contextlib
 import itertools
-import unittest
+import unittest 
 from distutils.errors import DistutilsError, DistutilsOptionError
 from distutils import log
 from unittest import TestLoader
 
-from setuptools.extern import six
-from setuptools.extern.six.moves import map, filter
+from setuptools.extern import six 
+from setuptools.extern.six.moves import map, filter 
 
 from pkg_resources import (resource_listdir, resource_exists, normalize_path,
-                           working_set, _namespace_packages, evaluate_marker,
+                           working_set, _namespace_packages, evaluate_marker, 
                            add_activation_listener, require, EntryPoint)
 from setuptools import Command
-from .build_py import _unique_everseen
-
-__metaclass__ = type
+from .build_py import _unique_everseen 
 
+__metaclass__ = type 
 
+ 
 class ScanningLoader(TestLoader):
-
-    def __init__(self):
-        TestLoader.__init__(self)
-        self._visited = set()
-
+ 
+    def __init__(self): 
+        TestLoader.__init__(self) 
+        self._visited = set() 
+ 
     def loadTestsFromModule(self, module, pattern=None):
         """Return a suite of all tests cases contained in the given module
 
@@ -33,10 +33,10 @@ class ScanningLoader(TestLoader):
         If the module has an ``additional_tests`` function, call it and add
         the return value to the tests.
         """
-        if module in self._visited:
-            return None
-        self._visited.add(module)
-
+        if module in self._visited: 
+            return None 
+        self._visited.add(module) 
+ 
         tests = []
         tests.append(TestLoader.loadTestsFromModule(self, module))
 
@@ -61,7 +61,7 @@ class ScanningLoader(TestLoader):
 
 
 # adapted from jaraco.classes.properties:NonDataProperty
-class NonDataProperty:
+class NonDataProperty: 
     def __init__(self, fget):
         self.fget = fget
 
@@ -74,12 +74,12 @@ class NonDataProperty:
 class test(Command):
     """Command to run unit tests after in-place build"""
 
-    description = "run unit tests after in-place build (deprecated)"
+    description = "run unit tests after in-place build (deprecated)" 
 
     user_options = [
         ('test-module=', 'm', "Run 'test_suite' in specified module"),
         ('test-suite=', 's',
-         "Run single test, case or suite (e.g. 'module.test_suite')"),
+         "Run single test, case or suite (e.g. 'module.test_suite')"), 
         ('test-runner=', 'r', "Test runner to use"),
     ]
 
@@ -113,8 +113,8 @@ class test(Command):
         return list(self._test_args())
 
     def _test_args(self):
-        if not self.test_suite and sys.version_info >= (2, 7):
-            yield 'discover'
+        if not self.test_suite and sys.version_info >= (2, 7): 
+            yield 'discover' 
         if self.verbose:
             yield '--verbose'
         if self.test_suite:
@@ -129,7 +129,7 @@ class test(Command):
 
     @contextlib.contextmanager
     def project_on_sys_path(self, include_dists=[]):
-        with_2to3 = not six.PY2 and getattr(self.distribution, 'use_2to3', False)
+        with_2to3 = not six.PY2 and getattr(self.distribution, 'use_2to3', False) 
 
         if with_2to3:
             # If we run 2to3 we can not do this inplace:
@@ -187,7 +187,7 @@ class test(Command):
         orig_pythonpath = os.environ.get('PYTHONPATH', nothing)
         current_pythonpath = os.environ.get('PYTHONPATH', '')
         try:
-            prefix = os.pathsep.join(_unique_everseen(paths))
+            prefix = os.pathsep.join(_unique_everseen(paths)) 
             to_join = filter(None, [prefix, current_pythonpath])
             new_path = os.pathsep.join(to_join)
             if new_path:
@@ -205,23 +205,23 @@ class test(Command):
         Install the requirements indicated by self.distribution and
         return an iterable of the dists that were built.
         """
-        ir_d = dist.fetch_build_eggs(dist.install_requires)
+        ir_d = dist.fetch_build_eggs(dist.install_requires) 
         tr_d = dist.fetch_build_eggs(dist.tests_require or [])
-        er_d = dist.fetch_build_eggs(
-            v for k, v in dist.extras_require.items()
-            if k.startswith(':') and evaluate_marker(k[1:])
-        )
-        return itertools.chain(ir_d, tr_d, er_d)
+        er_d = dist.fetch_build_eggs( 
+            v for k, v in dist.extras_require.items() 
+            if k.startswith(':') and evaluate_marker(k[1:]) 
+        ) 
+        return itertools.chain(ir_d, tr_d, er_d) 
 
     def run(self):
-        self.announce(
-            "WARNING: Testing via this command is deprecated and will be "
-            "removed in a future version. Users looking for a generic test "
-            "entry point independent of test runner are encouraged to use "
-            "tox.",
-            log.WARN,
-        )
-
+        self.announce( 
+            "WARNING: Testing via this command is deprecated and will be " 
+            "removed in a future version. Users looking for a generic test " 
+            "entry point independent of test runner are encouraged to use " 
+            "tox.", 
+            log.WARN, 
+        ) 
+ 
         installed_dists = self.install_dists(self.distribution)
 
         cmd = ' '.join(self._argv)
@@ -240,7 +240,7 @@ class test(Command):
         # Purge modules under test from sys.modules. The test loader will
         # re-import them from the build location. Required when 2to3 is used
         # with namespace packages.
-        if not six.PY2 and getattr(self.distribution, 'use_2to3', False):
+        if not six.PY2 and getattr(self.distribution, 'use_2to3', False): 
             module = self.test_suite.split('.')[0]
             if module in _namespace_packages:
                 del_modules = []
@@ -252,11 +252,11 @@ class test(Command):
                         del_modules.append(name)
                 list(map(sys.modules.__delitem__, del_modules))
 
-        test = unittest.main(
+        test = unittest.main( 
             None, None, self._argv,
             testLoader=self._resolve_as_ep(self.test_loader),
             testRunner=self._resolve_as_ep(self.test_runner),
-            exit=False,
+            exit=False, 
         )
         if not test.result.wasSuccessful():
             msg = 'Test failed: %s' % test.result
diff --git a/contrib/python/setuptools/py2/setuptools/command/upload.py b/contrib/python/setuptools/py2/setuptools/command/upload.py
index ec7f81e227..63cf4b7056 100644
--- a/contrib/python/setuptools/py2/setuptools/command/upload.py
+++ b/contrib/python/setuptools/py2/setuptools/command/upload.py
@@ -1,17 +1,17 @@
-from distutils import log
+from distutils import log 
 from distutils.command import upload as orig
 
-from setuptools.errors import RemovedCommandError
+from setuptools.errors import RemovedCommandError 
 
-
-class upload(orig.upload):
-    """Formerly used to upload packages to PyPI."""
-
-    def run(self):
-        msg = (
-            "The upload command has been removed, use twine to upload "
-            + "instead (https://pypi.org/p/twine)"
+ 
+class upload(orig.upload): 
+    """Formerly used to upload packages to PyPI.""" 
+ 
+    def run(self): 
+        msg = ( 
+            "The upload command has been removed, use twine to upload " 
+            + "instead (https://pypi.org/p/twine)" 
         )
 
-        self.announce("ERROR: " + msg, log.ERROR)
-        raise RemovedCommandError(msg)
+        self.announce("ERROR: " + msg, log.ERROR) 
+        raise RemovedCommandError(msg) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/upload_docs.py b/contrib/python/setuptools/py2/setuptools/command/upload_docs.py
index 130a0cb6c9..110e4b50eb 100644
--- a/contrib/python/setuptools/py2/setuptools/command/upload_docs.py
+++ b/contrib/python/setuptools/py2/setuptools/command/upload_docs.py
@@ -16,15 +16,15 @@ import shutil
 import itertools
 import functools
 
-from setuptools.extern import six
-from setuptools.extern.six.moves import http_client, urllib
+from setuptools.extern import six 
+from setuptools.extern.six.moves import http_client, urllib 
 
 from pkg_resources import iter_entry_points
 from .upload import upload
 
 
 def _encode(s):
-    errors = 'strict' if six.PY2 else 'surrogateescape'
+    errors = 'strict' if six.PY2 else 'surrogateescape' 
     return s.encode('utf-8', errors)
 
 
@@ -68,8 +68,8 @@ class upload_docs(upload):
         else:
             self.ensure_dirname('upload_dir')
             self.target_dir = self.upload_dir
-        if 'pypi.python.org' in self.repository:
-            log.warn("Upload_docs command is deprecated. Use RTD instead.")
+        if 'pypi.python.org' in self.repository: 
+            log.warn("Upload_docs command is deprecated. Use RTD instead.") 
         self.announce('Using upload directory %s' % self.target_dir)
 
     def create_zipfile(self, filename):
@@ -153,7 +153,7 @@ class upload_docs(upload):
         # set up the authentication
         credentials = _encode(self.username + ':' + self.password)
         credentials = standard_b64encode(credentials)
-        if not six.PY2:
+        if not six.PY2: 
             credentials = credentials.decode('ascii')
         auth = "Basic " + credentials
 
diff --git a/contrib/python/setuptools/py2/setuptools/config.py b/contrib/python/setuptools/py2/setuptools/config.py
index 9b9a0c45e7..305eea0d70 100644
--- a/contrib/python/setuptools/py2/setuptools/config.py
+++ b/contrib/python/setuptools/py2/setuptools/config.py
@@ -2,23 +2,23 @@ from __future__ import absolute_import, unicode_literals
 import io
 import os
 import sys
-
-import warnings
-import functools
+ 
+import warnings 
+import functools 
 from collections import defaultdict
 from functools import partial
-from functools import wraps
-from importlib import import_module
+from functools import wraps 
+from importlib import import_module 
 
 from distutils.errors import DistutilsOptionError, DistutilsFileError
-from setuptools.extern.packaging.version import LegacyVersion, parse
-from setuptools.extern.packaging.specifiers import SpecifierSet
-from setuptools.extern.six import string_types, PY3
-
-
-__metaclass__ = type
+from setuptools.extern.packaging.version import LegacyVersion, parse 
+from setuptools.extern.packaging.specifiers import SpecifierSet 
+from setuptools.extern.six import string_types, PY3 
 
 
+__metaclass__ = type 
+ 
+ 
 def read_configuration(
         filepath, find_others=False, ignore_option_errors=False):
     """Read given configuration file and returns options from it as a dict.
@@ -66,18 +66,18 @@ def read_configuration(
     return configuration_to_dict(handlers)
 
 
-def _get_option(target_obj, key):
-    """
-    Given a target object and option key, get that option from
-    the target object, either through a get_{key} method or
-    from an attribute directly.
-    """
-    getter_name = 'get_{key}'.format(**locals())
-    by_attribute = functools.partial(getattr, target_obj, key)
-    getter = getattr(target_obj, getter_name, by_attribute)
-    return getter()
-
-
+def _get_option(target_obj, key): 
+    """ 
+    Given a target object and option key, get that option from 
+    the target object, either through a get_{key} method or 
+    from an attribute directly. 
+    """ 
+    getter_name = 'get_{key}'.format(**locals()) 
+    by_attribute = functools.partial(getattr, target_obj, key) 
+    getter = getattr(target_obj, getter_name, by_attribute) 
+    return getter() 
+ 
+ 
 def configuration_to_dict(handlers):
     """Returns configuration data gathered by given handlers as a dict.
 
@@ -90,8 +90,8 @@ def configuration_to_dict(handlers):
 
     for handler in handlers:
         for option in handler.set_options:
-            value = _get_option(handler.target_obj, option)
-            config_dict[handler.section_prefix][option] = value
+            value = _get_option(handler.target_obj, option) 
+            config_dict[handler.section_prefix][option] = value 
 
     return config_dict
 
@@ -115,15 +115,15 @@ def parse_configuration(
         distribution, command_options, ignore_option_errors)
     options.parse()
 
-    meta = ConfigMetadataHandler(
-        distribution.metadata, command_options, ignore_option_errors,
-        distribution.package_dir)
-    meta.parse()
+    meta = ConfigMetadataHandler( 
+        distribution.metadata, command_options, ignore_option_errors, 
+        distribution.package_dir) 
+    meta.parse() 
 
-    return meta, options
+    return meta, options 
 
-
-class ConfigHandler:
+ 
+class ConfigHandler: 
     """Handles metadata supplied in configuration files."""
 
     section_prefix = None
@@ -248,26 +248,26 @@ class ConfigHandler:
         return value in ('1', 'true', 'yes')
 
     @classmethod
-    def _exclude_files_parser(cls, key):
-        """Returns a parser function to make sure field inputs
-        are not files.
-
-        Parses a value after getting the key so error messages are
-        more informative.
-
-        :param key:
-        :rtype: callable
-        """
-        def parser(value):
-            exclude_directive = 'file:'
-            if value.startswith(exclude_directive):
-                raise ValueError(
-                    'Only strings are accepted for the {0} field, '
-                    'files are not accepted'.format(key))
-            return value
-        return parser
-
-    @classmethod
+    def _exclude_files_parser(cls, key): 
+        """Returns a parser function to make sure field inputs 
+        are not files. 
+ 
+        Parses a value after getting the key so error messages are 
+        more informative. 
+ 
+        :param key: 
+        :rtype: callable 
+        """ 
+        def parser(value): 
+            exclude_directive = 'file:' 
+            if value.startswith(exclude_directive): 
+                raise ValueError( 
+                    'Only strings are accepted for the {0} field, ' 
+                    'files are not accepted'.format(key)) 
+            return value 
+        return parser 
+ 
+    @classmethod 
     def _parse_file(cls, value):
         """Represents value as a string, allowing including text
         from nearest files using `file:` directive.
@@ -276,41 +276,41 @@ class ConfigHandler:
         directory with setup.py.
 
         Examples:
-            file: README.rst, CHANGELOG.md, src/file.txt
+            file: README.rst, CHANGELOG.md, src/file.txt 
 
         :param str value:
         :rtype: str
         """
-        include_directive = 'file:'
-
+        include_directive = 'file:' 
+ 
         if not isinstance(value, string_types):
             return value
 
         if not value.startswith(include_directive):
             return value
 
-        spec = value[len(include_directive):]
-        filepaths = (os.path.abspath(path.strip()) for path in spec.split(','))
-        return '\n'.join(
-            cls._read_file(path)
-            for path in filepaths
-            if (cls._assert_local(path) or True)
-            and os.path.isfile(path)
-        )
-
-    @staticmethod
-    def _assert_local(filepath):
-        if not filepath.startswith(os.getcwd()):
+        spec = value[len(include_directive):] 
+        filepaths = (os.path.abspath(path.strip()) for path in spec.split(',')) 
+        return '\n'.join( 
+            cls._read_file(path) 
+            for path in filepaths 
+            if (cls._assert_local(path) or True) 
+            and os.path.isfile(path) 
+        ) 
+
+    @staticmethod 
+    def _assert_local(filepath): 
+        if not filepath.startswith(os.getcwd()): 
             raise DistutilsOptionError(
                 '`file:` directive can not access %s' % filepath)
 
-    @staticmethod
-    def _read_file(filepath):
-        with io.open(filepath, encoding='utf-8') as f:
-            return f.read()
+    @staticmethod 
+    def _read_file(filepath): 
+        with io.open(filepath, encoding='utf-8') as f: 
+            return f.read() 
 
     @classmethod
-    def _parse_attr(cls, value, package_dir=None):
+    def _parse_attr(cls, value, package_dir=None): 
         """Represents value as a module attribute.
 
         Examples:
@@ -330,21 +330,21 @@ class ConfigHandler:
         module_name = '.'.join(attrs_path)
         module_name = module_name or '__init__'
 
-        parent_path = os.getcwd()
-        if package_dir:
-            if attrs_path[0] in package_dir:
-                # A custom path was specified for the module we want to import
-                custom_path = package_dir[attrs_path[0]]
-                parts = custom_path.rsplit('/', 1)
-                if len(parts) > 1:
-                    parent_path = os.path.join(os.getcwd(), parts[0])
-                    module_name = parts[1]
-                else:
-                    module_name = custom_path
-            elif '' in package_dir:
-                # A custom parent directory was specified for all root modules
-                parent_path = os.path.join(os.getcwd(), package_dir[''])
-        sys.path.insert(0, parent_path)
+        parent_path = os.getcwd() 
+        if package_dir: 
+            if attrs_path[0] in package_dir: 
+                # A custom path was specified for the module we want to import 
+                custom_path = package_dir[attrs_path[0]] 
+                parts = custom_path.rsplit('/', 1) 
+                if len(parts) > 1: 
+                    parent_path = os.path.join(os.getcwd(), parts[0]) 
+                    module_name = parts[1] 
+                else: 
+                    module_name = custom_path 
+            elif '' in package_dir: 
+                # A custom parent directory was specified for all root modules 
+                parent_path = os.path.join(os.getcwd(), package_dir['']) 
+        sys.path.insert(0, parent_path) 
         try:
             module = import_module(module_name)
             value = getattr(module, attr_name)
@@ -414,7 +414,7 @@ class ConfigHandler:
 
             section_parser_method = getattr(
                 self,
-                # Dots in section names are translated into dunderscores.
+                # Dots in section names are translated into dunderscores. 
                 ('parse_section%s' % method_postfix).replace('.', '__'),
                 None)
 
@@ -425,21 +425,21 @@ class ConfigHandler:
 
             section_parser_method(section_options)
 
-    def _deprecated_config_handler(self, func, msg, warning_class):
-        """ this function will wrap around parameters that are deprecated
-
-        :param msg: deprecation message
-        :param warning_class: class of warning exception to be raised
-        :param func: function to be wrapped around
-        """
-        @wraps(func)
-        def config_handler(*args, **kwargs):
-            warnings.warn(msg, warning_class)
-            return func(*args, **kwargs)
-
-        return config_handler
-
-
+    def _deprecated_config_handler(self, func, msg, warning_class): 
+        """ this function will wrap around parameters that are deprecated 
+
+        :param msg: deprecation message 
+        :param warning_class: class of warning exception to be raised 
+        :param func: function to be wrapped around 
+        """ 
+        @wraps(func) 
+        def config_handler(*args, **kwargs): 
+            warnings.warn(msg, warning_class) 
+            return func(*args, **kwargs) 
+ 
+        return config_handler 
+ 
+ 
 class ConfigMetadataHandler(ConfigHandler):
 
     section_prefix = 'metadata'
@@ -457,37 +457,37 @@ class ConfigMetadataHandler(ConfigHandler):
 
     """
 
-    def __init__(self, target_obj, options, ignore_option_errors=False,
-                 package_dir=None):
-        super(ConfigMetadataHandler, self).__init__(target_obj, options,
-                                                    ignore_option_errors)
-        self.package_dir = package_dir
-
+    def __init__(self, target_obj, options, ignore_option_errors=False, 
+                 package_dir=None): 
+        super(ConfigMetadataHandler, self).__init__(target_obj, options, 
+                                                    ignore_option_errors) 
+        self.package_dir = package_dir 
+ 
     @property
     def parsers(self):
         """Metadata item name to parser function mapping."""
         parse_list = self._parse_list
         parse_file = self._parse_file
-        parse_dict = self._parse_dict
-        exclude_files_parser = self._exclude_files_parser
+        parse_dict = self._parse_dict 
+        exclude_files_parser = self._exclude_files_parser 
 
         return {
             'platforms': parse_list,
             'keywords': parse_list,
             'provides': parse_list,
-            'requires': self._deprecated_config_handler(
-                parse_list,
-                "The requires parameter is deprecated, please use "
-                "install_requires for runtime dependencies.",
-                DeprecationWarning),
+            'requires': self._deprecated_config_handler( 
+                parse_list, 
+                "The requires parameter is deprecated, please use " 
+                "install_requires for runtime dependencies.", 
+                DeprecationWarning), 
             'obsoletes': parse_list,
             'classifiers': self._get_parser_compound(parse_file, parse_list),
-            'license': exclude_files_parser('license'),
-            'license_files': parse_list,
+            'license': exclude_files_parser('license'), 
+            'license_files': parse_list, 
             'description': parse_file,
             'long_description': parse_file,
             'version': self._parse_version,
-            'project_urls': parse_dict,
+            'project_urls': parse_dict, 
         }
 
     def _parse_version(self, value):
@@ -497,23 +497,23 @@ class ConfigMetadataHandler(ConfigHandler):
         :rtype: str
 
         """
-        version = self._parse_file(value)
-
-        if version != value:
-            version = version.strip()
-            # Be strict about versions loaded from file because it's easy to
-            # accidentally include newlines and other unintended content
-            if isinstance(parse(version), LegacyVersion):
-                tmpl = (
-                    'Version loaded from {value} does not '
-                    'comply with PEP 440: {version}'
-                )
-                raise DistutilsOptionError(tmpl.format(**locals()))
-
-            return version
-
-        version = self._parse_attr(value, self.package_dir)
-
+        version = self._parse_file(value) 
+
+        if version != value: 
+            version = version.strip() 
+            # Be strict about versions loaded from file because it's easy to 
+            # accidentally include newlines and other unintended content 
+            if isinstance(parse(version), LegacyVersion): 
+                tmpl = ( 
+                    'Version loaded from {value} does not ' 
+                    'comply with PEP 440: {version}' 
+                ) 
+                raise DistutilsOptionError(tmpl.format(**locals())) 
+ 
+            return version 
+ 
+        version = self._parse_attr(value, self.package_dir) 
+ 
         if callable(version):
             version = version()
 
@@ -555,8 +555,8 @@ class ConfigOptionsHandler(ConfigHandler):
             'tests_require': parse_list_semicolon,
             'packages': self._parse_packages,
             'entry_points': self._parse_file,
-            'py_modules': parse_list,
-            'python_requires': SpecifierSet,
+            'py_modules': parse_list, 
+            'python_requires': SpecifierSet, 
         }
 
     def _parse_packages(self, value):
@@ -565,25 +565,25 @@ class ConfigOptionsHandler(ConfigHandler):
         :param value:
         :rtype: list
         """
-        find_directives = ['find:', 'find_namespace:']
-        trimmed_value = value.strip()
+        find_directives = ['find:', 'find_namespace:'] 
+        trimmed_value = value.strip() 
 
-        if trimmed_value not in find_directives:
+        if trimmed_value not in find_directives: 
             return self._parse_list(value)
 
-        findns = trimmed_value == find_directives[1]
-        if findns and not PY3:
-            raise DistutilsOptionError(
-                'find_namespace: directive is unsupported on Python < 3.3')
-
+        findns = trimmed_value == find_directives[1] 
+        if findns and not PY3: 
+            raise DistutilsOptionError( 
+                'find_namespace: directive is unsupported on Python < 3.3') 
+ 
         # Read function arguments from a dedicated section.
         find_kwargs = self.parse_section_packages__find(
             self.sections.get('packages.find', {}))
 
-        if findns:
-            from setuptools import find_namespace_packages as find_packages
-        else:
-            from setuptools import find_packages
+        if findns: 
+            from setuptools import find_namespace_packages as find_packages 
+        else: 
+            from setuptools import find_packages 
 
         return find_packages(**find_kwargs)
 
@@ -649,11 +649,11 @@ class ConfigOptionsHandler(ConfigHandler):
         parse_list = partial(self._parse_list, separator=';')
         self['extras_require'] = self._parse_section_to_dict(
             section_options, parse_list)
-
-    def parse_section_data_files(self, section_options):
-        """Parses `data_files` configuration file section.
-
-        :param dict section_options:
-        """
-        parsed = self._parse_section_to_dict(section_options, self._parse_list)
-        self['data_files'] = [(k, v) for k, v in parsed.items()]
+ 
+    def parse_section_data_files(self, section_options): 
+        """Parses `data_files` configuration file section. 
+ 
+        :param dict section_options: 
+        """ 
+        parsed = self._parse_section_to_dict(section_options, self._parse_list) 
+        self['data_files'] = [(k, v) for k, v in parsed.items()] 
diff --git a/contrib/python/setuptools/py2/setuptools/depends.py b/contrib/python/setuptools/py2/setuptools/depends.py
index a37675cbd9..f342068122 100644
--- a/contrib/python/setuptools/py2/setuptools/depends.py
+++ b/contrib/python/setuptools/py2/setuptools/depends.py
@@ -1,14 +1,14 @@
 import sys
 import marshal
-import contextlib
+import contextlib 
 from distutils.version import StrictVersion
 
 from .py33compat import Bytecode
 
-from .py27compat import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE
-from . import py27compat
-
+from .py27compat import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE 
+from . import py27compat 
 
+ 
 __all__ = [
     'Require', 'find_module', 'get_module_constant', 'extract_constant'
 ]
@@ -17,8 +17,8 @@ __all__ = [
 class Require:
     """A prerequisite to building or installing a distribution"""
 
-    def __init__(
-            self, name, requested_version, module, homepage='',
+    def __init__( 
+            self, name, requested_version, module, homepage='', 
             attribute=None, format=None):
 
         if format is None and requested_version is not None:
@@ -82,15 +82,15 @@ class Require:
         return self.version_ok(version)
 
 
-def maybe_close(f):
-    @contextlib.contextmanager
-    def empty():
-        yield
-        return
-    if not f:
-        return empty()
+def maybe_close(f): 
+    @contextlib.contextmanager 
+    def empty(): 
+        yield 
+        return 
+    if not f: 
+        return empty() 
 
-    return contextlib.closing(f)
+    return contextlib.closing(f) 
 
 
 def get_module_constant(module, symbol, default=-1, paths=None):
@@ -101,23 +101,23 @@ def get_module_constant(module, symbol, default=-1, paths=None):
     constant.  Otherwise, return 'default'."""
 
     try:
-        f, path, (suffix, mode, kind) = info = find_module(module, paths)
+        f, path, (suffix, mode, kind) = info = find_module(module, paths) 
     except ImportError:
         # Module doesn't exist
         return None
 
-    with maybe_close(f):
+    with maybe_close(f): 
         if kind == PY_COMPILED:
             f.read(8)  # skip magic & date
             code = marshal.load(f)
         elif kind == PY_FROZEN:
-            code = py27compat.get_frozen_object(module, paths)
+            code = py27compat.get_frozen_object(module, paths) 
         elif kind == PY_SOURCE:
             code = compile(f.read(), path, 'exec')
         else:
             # Not something we can parse; we'll have to import it.  :(
-            imported = py27compat.get_module(module, paths, info)
-            return getattr(imported, symbol, None)
+            imported = py27compat.get_module(module, paths, info) 
+            return getattr(imported, symbol, None) 
 
     return extract_constant(code, symbol, default)
 
diff --git a/contrib/python/setuptools/py2/setuptools/dist.py b/contrib/python/setuptools/py2/setuptools/dist.py
index f6453a0878..6b053f0513 100644
--- a/contrib/python/setuptools/py2/setuptools/dist.py
+++ b/contrib/python/setuptools/py2/setuptools/dist.py
@@ -1,8 +1,8 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8 -*- 
 __all__ = ['Distribution']
 
-import io
-import sys
+import io 
+import sys 
 import re
 import os
 import warnings
@@ -11,172 +11,172 @@ import distutils.log
 import distutils.core
 import distutils.cmd
 import distutils.dist
-from distutils.util import strtobool
-from distutils.debug import DEBUG
-from distutils.fancy_getopt import translate_longopt
-import itertools
-
-from collections import defaultdict
-from email import message_from_file
-
-from distutils.errors import (
-    DistutilsOptionError, DistutilsPlatformError, DistutilsSetupError,
-)
+from distutils.util import strtobool 
+from distutils.debug import DEBUG 
+from distutils.fancy_getopt import translate_longopt 
+import itertools 
+ 
+from collections import defaultdict 
+from email import message_from_file 
+ 
+from distutils.errors import ( 
+    DistutilsOptionError, DistutilsPlatformError, DistutilsSetupError, 
+) 
 from distutils.util import rfc822_escape
-from distutils.version import StrictVersion
-
-from setuptools.extern import six
-from setuptools.extern import packaging
-from setuptools.extern import ordered_set
-from setuptools.extern.six.moves import map, filter, filterfalse
+from distutils.version import StrictVersion 
 
-from . import SetuptoolsDeprecationWarning
+from setuptools.extern import six 
+from setuptools.extern import packaging 
+from setuptools.extern import ordered_set 
+from setuptools.extern.six.moves import map, filter, filterfalse 
 
+from . import SetuptoolsDeprecationWarning 
+ 
 from setuptools.depends import Require
 from setuptools import windows_support
 from setuptools.monkey import get_unpatched
 from setuptools.config import parse_configuration
 import pkg_resources
 
-__import__('setuptools.extern.packaging.specifiers')
-__import__('setuptools.extern.packaging.version')
-
+__import__('setuptools.extern.packaging.specifiers') 
+__import__('setuptools.extern.packaging.version') 
 
+ 
 def _get_unpatched(cls):
-    warnings.warn("Do not call this function", DistDeprecationWarning)
+    warnings.warn("Do not call this function", DistDeprecationWarning) 
     return get_unpatched(cls)
 
 
-def get_metadata_version(self):
-    mv = getattr(self, 'metadata_version', None)
-
-    if mv is None:
-        if self.long_description_content_type or self.provides_extras:
-            mv = StrictVersion('2.1')
-        elif (self.maintainer is not None or
-              self.maintainer_email is not None or
-              getattr(self, 'python_requires', None) is not None or
-              self.project_urls):
-            mv = StrictVersion('1.2')
-        elif (self.provides or self.requires or self.obsoletes or
-                self.classifiers or self.download_url):
-            mv = StrictVersion('1.1')
-        else:
-            mv = StrictVersion('1.0')
-
-        self.metadata_version = mv
-
-    return mv
-
-
-def read_pkg_file(self, file):
-    """Reads the metadata values from a file object."""
-    msg = message_from_file(file)
-
-    def _read_field(name):
-        value = msg[name]
-        if value == 'UNKNOWN':
-            return None
-        return value
-
-    def _read_list(name):
-        values = msg.get_all(name, None)
-        if values == []:
-            return None
-        return values
-
-    self.metadata_version = StrictVersion(msg['metadata-version'])
-    self.name = _read_field('name')
-    self.version = _read_field('version')
-    self.description = _read_field('summary')
-    # we are filling author only.
-    self.author = _read_field('author')
-    self.maintainer = None
-    self.author_email = _read_field('author-email')
-    self.maintainer_email = None
-    self.url = _read_field('home-page')
-    self.license = _read_field('license')
-
-    if 'download-url' in msg:
-        self.download_url = _read_field('download-url')
-    else:
-        self.download_url = None
-
-    self.long_description = _read_field('description')
-    self.description = _read_field('summary')
-
-    if 'keywords' in msg:
-        self.keywords = _read_field('keywords').split(',')
-
-    self.platforms = _read_list('platform')
-    self.classifiers = _read_list('classifier')
-
-    # PEP 314 - these fields only exist in 1.1
-    if self.metadata_version == StrictVersion('1.1'):
-        self.requires = _read_list('requires')
-        self.provides = _read_list('provides')
-        self.obsoletes = _read_list('obsoletes')
-    else:
-        self.requires = None
-        self.provides = None
-        self.obsoletes = None
-
-
+def get_metadata_version(self): 
+    mv = getattr(self, 'metadata_version', None) 
+ 
+    if mv is None: 
+        if self.long_description_content_type or self.provides_extras: 
+            mv = StrictVersion('2.1') 
+        elif (self.maintainer is not None or 
+              self.maintainer_email is not None or 
+              getattr(self, 'python_requires', None) is not None or 
+              self.project_urls): 
+            mv = StrictVersion('1.2') 
+        elif (self.provides or self.requires or self.obsoletes or 
+                self.classifiers or self.download_url): 
+            mv = StrictVersion('1.1') 
+        else: 
+            mv = StrictVersion('1.0') 
+ 
+        self.metadata_version = mv 
+ 
+    return mv 
+ 
+ 
+def read_pkg_file(self, file): 
+    """Reads the metadata values from a file object.""" 
+    msg = message_from_file(file) 
+ 
+    def _read_field(name): 
+        value = msg[name] 
+        if value == 'UNKNOWN': 
+            return None 
+        return value 
+ 
+    def _read_list(name): 
+        values = msg.get_all(name, None) 
+        if values == []: 
+            return None 
+        return values 
+ 
+    self.metadata_version = StrictVersion(msg['metadata-version']) 
+    self.name = _read_field('name') 
+    self.version = _read_field('version') 
+    self.description = _read_field('summary') 
+    # we are filling author only. 
+    self.author = _read_field('author') 
+    self.maintainer = None 
+    self.author_email = _read_field('author-email') 
+    self.maintainer_email = None 
+    self.url = _read_field('home-page') 
+    self.license = _read_field('license') 
+ 
+    if 'download-url' in msg: 
+        self.download_url = _read_field('download-url') 
+    else: 
+        self.download_url = None 
+ 
+    self.long_description = _read_field('description') 
+    self.description = _read_field('summary') 
+ 
+    if 'keywords' in msg: 
+        self.keywords = _read_field('keywords').split(',') 
+ 
+    self.platforms = _read_list('platform') 
+    self.classifiers = _read_list('classifier') 
+ 
+    # PEP 314 - these fields only exist in 1.1 
+    if self.metadata_version == StrictVersion('1.1'): 
+        self.requires = _read_list('requires') 
+        self.provides = _read_list('provides') 
+        self.obsoletes = _read_list('obsoletes') 
+    else: 
+        self.requires = None 
+        self.provides = None 
+        self.obsoletes = None 
+ 
+ 
 # Based on Python 3.5 version
 def write_pkg_file(self, file):
     """Write the PKG-INFO format data to a file object.
     """
-    version = self.get_metadata_version()
-
-    if six.PY2:
-        def write_field(key, value):
-            file.write("%s: %s\n" % (key, self._encode_field(value)))
-    else:
-        def write_field(key, value):
-            file.write("%s: %s\n" % (key, value))
-
-    write_field('Metadata-Version', str(version))
-    write_field('Name', self.get_name())
-    write_field('Version', self.get_version())
-    write_field('Summary', self.get_description())
-    write_field('Home-page', self.get_url())
-
-    if version < StrictVersion('1.2'):
-        write_field('Author', self.get_contact())
-        write_field('Author-email', self.get_contact_email())
-    else:
-        optional_fields = (
-            ('Author', 'author'),
-            ('Author-email', 'author_email'),
-            ('Maintainer', 'maintainer'),
-            ('Maintainer-email', 'maintainer_email'),
-        )
-
-        for field, attr in optional_fields:
-            attr_val = getattr(self, attr)
-
-            if attr_val is not None:
-                write_field(field, attr_val)
-
-    write_field('License', self.get_license())
+    version = self.get_metadata_version() 
+
+    if six.PY2: 
+        def write_field(key, value): 
+            file.write("%s: %s\n" % (key, self._encode_field(value))) 
+    else: 
+        def write_field(key, value): 
+            file.write("%s: %s\n" % (key, value)) 
+ 
+    write_field('Metadata-Version', str(version)) 
+    write_field('Name', self.get_name()) 
+    write_field('Version', self.get_version()) 
+    write_field('Summary', self.get_description()) 
+    write_field('Home-page', self.get_url()) 
+ 
+    if version < StrictVersion('1.2'): 
+        write_field('Author', self.get_contact()) 
+        write_field('Author-email', self.get_contact_email()) 
+    else: 
+        optional_fields = ( 
+            ('Author', 'author'), 
+            ('Author-email', 'author_email'), 
+            ('Maintainer', 'maintainer'), 
+            ('Maintainer-email', 'maintainer_email'), 
+        ) 
+ 
+        for field, attr in optional_fields: 
+            attr_val = getattr(self, attr) 
+ 
+            if attr_val is not None: 
+                write_field(field, attr_val) 
+ 
+    write_field('License', self.get_license()) 
     if self.download_url:
-        write_field('Download-URL', self.download_url)
-    for project_url in self.project_urls.items():
-        write_field('Project-URL',  '%s, %s' % project_url)
+        write_field('Download-URL', self.download_url) 
+    for project_url in self.project_urls.items(): 
+        write_field('Project-URL',  '%s, %s' % project_url) 
 
     long_desc = rfc822_escape(self.get_long_description())
-    write_field('Description', long_desc)
+    write_field('Description', long_desc) 
 
     keywords = ','.join(self.get_keywords())
     if keywords:
-        write_field('Keywords', keywords)
-
-    if version >= StrictVersion('1.2'):
-        for platform in self.get_platforms():
-            write_field('Platform', platform)
-    else:
-        self._write_list(file, 'Platform', self.get_platforms())
-
+        write_field('Keywords', keywords) 
+
+    if version >= StrictVersion('1.2'): 
+        for platform in self.get_platforms(): 
+            write_field('Platform', platform) 
+    else: 
+        self._write_list(file, 'Platform', self.get_platforms()) 
+ 
     self._write_list(file, 'Classifier', self.get_classifiers())
 
     # PEP 314
@@ -186,17 +186,17 @@ def write_pkg_file(self, file):
 
     # Setuptools specific for PEP 345
     if hasattr(self, 'python_requires'):
-        write_field('Requires-Python', self.python_requires)
+        write_field('Requires-Python', self.python_requires) 
 
-    # PEP 566
-    if self.long_description_content_type:
-        write_field(
-            'Description-Content-Type',
-            self.long_description_content_type
-        )
-    if self.provides_extras:
-        for extra in self.provides_extras:
-            write_field('Provides-Extra', extra)
+    # PEP 566 
+    if self.long_description_content_type: 
+        write_field( 
+            'Description-Content-Type', 
+            self.long_description_content_type 
+        ) 
+    if self.provides_extras: 
+        for extra in self.provides_extras: 
+            write_field('Provides-Extra', extra) 
 
 
 sequence = tuple, list
@@ -214,12 +214,12 @@ def check_importable(dist, attr, value):
 
 
 def assert_string_list(dist, attr, value):
-    """Verify that value is a string list"""
+    """Verify that value is a string list""" 
     try:
-        # verify that value is a list or tuple to exclude unordered
-        # or single-use iterables
-        assert isinstance(value, (list, tuple))
-        # verify that elements of value are strings
+        # verify that value is a list or tuple to exclude unordered 
+        # or single-use iterables 
+        assert isinstance(value, (list, tuple)) 
+        # verify that elements of value are strings 
         assert ''.join(value) != value
     except (TypeError, ValueError, AttributeError, AssertionError):
         raise DistutilsSetupError(
@@ -248,7 +248,7 @@ def check_nsp(dist, attr, value):
 def check_extras(dist, attr, value):
     """Verify that extras_require mapping is valid"""
     try:
-        list(itertools.starmap(_check_extra, value.items()))
+        list(itertools.starmap(_check_extra, value.items())) 
     except (TypeError, ValueError, AttributeError):
         raise DistutilsSetupError(
             "'extras_require' must be a dictionary whose values are "
@@ -257,13 +257,13 @@ def check_extras(dist, attr, value):
         )
 
 
-def _check_extra(extra, reqs):
-    name, sep, marker = extra.partition(':')
-    if marker and pkg_resources.invalid_marker(marker):
-        raise DistutilsSetupError("Invalid environment marker: " + marker)
-    list(pkg_resources.parse_requirements(reqs))
-
-
+def _check_extra(extra, reqs): 
+    name, sep, marker = extra.partition(':') 
+    if marker and pkg_resources.invalid_marker(marker): 
+        raise DistutilsSetupError("Invalid environment marker: " + marker) 
+    list(pkg_resources.parse_requirements(reqs)) 
+ 
+ 
 def assert_bool(dist, attr, value):
     """Verify that value is True, False, 0, or 1"""
     if bool(value) != value:
@@ -275,8 +275,8 @@ def check_requirements(dist, attr, value):
     """Verify that install_requires is a valid requirements list"""
     try:
         list(pkg_resources.parse_requirements(value))
-        if isinstance(value, (dict, set)):
-            raise TypeError("Unordered types are not allowed")
+        if isinstance(value, (dict, set)): 
+            raise TypeError("Unordered types are not allowed") 
     except (TypeError, ValueError) as error:
         tmpl = (
             "{attr!r} must be a string or list of strings "
@@ -291,7 +291,7 @@ def check_specifier(dist, attr, value):
         packaging.specifiers.SpecifierSet(value)
     except packaging.specifiers.InvalidSpecifier as error:
         tmpl = (
-            "{attr!r} must be a string "
+            "{attr!r} must be a string " 
             "containing valid version specifiers; {error}"
         )
         raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
@@ -312,17 +312,17 @@ def check_test_suite(dist, attr, value):
 
 def check_package_data(dist, attr, value):
     """Verify that value is a dictionary of package names to glob lists"""
-    if not isinstance(value, dict):
-        raise DistutilsSetupError(
-            "{!r} must be a dictionary mapping package names to lists of "
-            "string wildcard patterns".format(attr))
-    for k, v in value.items():
-        if not isinstance(k, six.string_types):
-            raise DistutilsSetupError(
-                "keys of {!r} dict must be strings (got {!r})"
-                .format(attr, k)
-            )
-        assert_string_list(dist, 'values of {!r} dict'.format(attr), v)
+    if not isinstance(value, dict): 
+        raise DistutilsSetupError( 
+            "{!r} must be a dictionary mapping package names to lists of " 
+            "string wildcard patterns".format(attr)) 
+    for k, v in value.items(): 
+        if not isinstance(k, six.string_types): 
+            raise DistutilsSetupError( 
+                "keys of {!r} dict must be strings (got {!r})" 
+                .format(attr, k) 
+            ) 
+        assert_string_list(dist, 'values of {!r} dict'.format(attr), v) 
 
 
 def check_packages(dist, attr, value):
@@ -337,7 +337,7 @@ def check_packages(dist, attr, value):
 _Distribution = get_unpatched(distutils.core.Distribution)
 
 
-class Distribution(_Distribution):
+class Distribution(_Distribution): 
     """Distribution with support for features, tests, and package data
 
     This is an enhanced version of 'distutils.dist.Distribution' that
@@ -405,13 +405,13 @@ class Distribution(_Distribution):
     distribution for the included and excluded features.
     """
 
-    _DISTUTILS_UNSUPPORTED_METADATA = {
-        'long_description_content_type': None,
-        'project_urls': dict,
-        'provides_extras': ordered_set.OrderedSet,
-        'license_files': ordered_set.OrderedSet,
-    }
-
+    _DISTUTILS_UNSUPPORTED_METADATA = { 
+        'long_description_content_type': None, 
+        'project_urls': dict, 
+        'provides_extras': ordered_set.OrderedSet, 
+        'license_files': ordered_set.OrderedSet, 
+    } 
+ 
     _patched_dist = None
 
     def patch_missing_pkg_info(self, attrs):
@@ -431,36 +431,36 @@ class Distribution(_Distribution):
         have_package_data = hasattr(self, "package_data")
         if not have_package_data:
             self.package_data = {}
-        attrs = attrs or {}
-        if 'features' in attrs or 'require_features' in attrs:
+        attrs = attrs or {} 
+        if 'features' in attrs or 'require_features' in attrs: 
             Feature.warn_deprecated()
         self.require_features = []
         self.features = {}
         self.dist_files = []
-        # Filter-out setuptools' specific options.
-        self.src_root = attrs.pop("src_root", None)
+        # Filter-out setuptools' specific options. 
+        self.src_root = attrs.pop("src_root", None) 
         self.patch_missing_pkg_info(attrs)
-        self.dependency_links = attrs.pop('dependency_links', [])
-        self.setup_requires = attrs.pop('setup_requires', [])
+        self.dependency_links = attrs.pop('dependency_links', []) 
+        self.setup_requires = attrs.pop('setup_requires', []) 
         for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
             vars(self).setdefault(ep.name, None)
-        _Distribution.__init__(self, {
-            k: v for k, v in attrs.items()
-            if k not in self._DISTUTILS_UNSUPPORTED_METADATA
-        })
-
-        # Fill-in missing metadata fields not supported by distutils.
-        # Note some fields may have been set by other tools (e.g. pbr)
-        # above; they are taken preferrentially to setup() arguments
-        for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items():
-            for source in self.metadata.__dict__, attrs:
-                if option in source:
-                    value = source[option]
-                    break
-            else:
-                value = default() if default else None
-            setattr(self.metadata, option, value)
-
+        _Distribution.__init__(self, { 
+            k: v for k, v in attrs.items() 
+            if k not in self._DISTUTILS_UNSUPPORTED_METADATA 
+        }) 
+ 
+        # Fill-in missing metadata fields not supported by distutils. 
+        # Note some fields may have been set by other tools (e.g. pbr) 
+        # above; they are taken preferrentially to setup() arguments 
+        for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items(): 
+            for source in self.metadata.__dict__, attrs: 
+                if option in source: 
+                    value = source[option] 
+                    break 
+            else: 
+                value = default() if default else None 
+            setattr(self.metadata, option, value) 
+ 
         if isinstance(self.metadata.version, numbers.Number):
             # Some people apparently take "version number" too literally :)
             self.metadata.version = str(self.metadata.version)
@@ -484,223 +484,223 @@ class Distribution(_Distribution):
                     "setuptools, pip, and PyPI. Please see PEP 440 for more "
                     "details." % self.metadata.version
                 )
-        self._finalize_requires()
-
-    def _finalize_requires(self):
-        """
-        Set `metadata.python_requires` and fix environment markers
-        in `install_requires` and `extras_require`.
-        """
+        self._finalize_requires() 
+ 
+    def _finalize_requires(self): 
+        """ 
+        Set `metadata.python_requires` and fix environment markers 
+        in `install_requires` and `extras_require`. 
+        """ 
         if getattr(self, 'python_requires', None):
             self.metadata.python_requires = self.python_requires
 
-        if getattr(self, 'extras_require', None):
-            for extra in self.extras_require.keys():
-                # Since this gets called multiple times at points where the
-                # keys have become 'converted' extras, ensure that we are only
-                # truly adding extras we haven't seen before here.
-                extra = extra.split(':')[0]
-                if extra:
-                    self.metadata.provides_extras.add(extra)
-
-        self._convert_extras_requirements()
-        self._move_install_requirements_markers()
-
-    def _convert_extras_requirements(self):
-        """
-        Convert requirements in `extras_require` of the form
-        `"extra": ["barbazquux; {marker}"]` to
-        `"extra:{marker}": ["barbazquux"]`.
-        """
-        spec_ext_reqs = getattr(self, 'extras_require', None) or {}
-        self._tmp_extras_require = defaultdict(list)
-        for section, v in spec_ext_reqs.items():
-            # Do not strip empty sections.
-            self._tmp_extras_require[section]
-            for r in pkg_resources.parse_requirements(v):
-                suffix = self._suffix_for(r)
-                self._tmp_extras_require[section + suffix].append(r)
-
-    @staticmethod
-    def _suffix_for(req):
-        """
-        For a requirement, return the 'extras_require' suffix for
-        that requirement.
-        """
-        return ':' + str(req.marker) if req.marker else ''
-
-    def _move_install_requirements_markers(self):
-        """
-        Move requirements in `install_requires` that are using environment
-        markers `extras_require`.
-        """
-
-        # divide the install_requires into two sets, simple ones still
-        # handled by install_requires and more complex ones handled
-        # by extras_require.
-
-        def is_simple_req(req):
-            return not req.marker
-
-        spec_inst_reqs = getattr(self, 'install_requires', None) or ()
-        inst_reqs = list(pkg_resources.parse_requirements(spec_inst_reqs))
-        simple_reqs = filter(is_simple_req, inst_reqs)
-        complex_reqs = filterfalse(is_simple_req, inst_reqs)
-        self.install_requires = list(map(str, simple_reqs))
-
-        for r in complex_reqs:
-            self._tmp_extras_require[':' + str(r.marker)].append(r)
-        self.extras_require = dict(
-            (k, [str(r) for r in map(self._clean_req, v)])
-            for k, v in self._tmp_extras_require.items()
-        )
-
-    def _clean_req(self, req):
-        """
-        Given a Requirement, remove environment markers and return it.
-        """
-        req.marker = None
-        return req
-
-    def _parse_config_files(self, filenames=None):
-        """
-        Adapted from distutils.dist.Distribution.parse_config_files,
-        this method provides the same functionality in subtly-improved
-        ways.
-        """
-        from setuptools.extern.six.moves.configparser import ConfigParser
-
-        # Ignore install directory options if we have a venv
-        if not six.PY2 and sys.prefix != sys.base_prefix:
-            ignore_options = [
-                'install-base', 'install-platbase', 'install-lib',
-                'install-platlib', 'install-purelib', 'install-headers',
-                'install-scripts', 'install-data', 'prefix', 'exec-prefix',
-                'home', 'user', 'root']
-        else:
-            ignore_options = []
-
-        ignore_options = frozenset(ignore_options)
-
-        if filenames is None:
-            filenames = self.find_config_files()
-
-        if DEBUG:
-            self.announce("Distribution.parse_config_files():")
-
-        parser = ConfigParser()
-        for filename in filenames:
-            with io.open(filename, encoding='utf-8') as reader:
-                if DEBUG:
-                    self.announce("  reading {filename}".format(**locals()))
-                (parser.readfp if six.PY2 else parser.read_file)(reader)
-            for section in parser.sections():
-                options = parser.options(section)
-                opt_dict = self.get_option_dict(section)
-
-                for opt in options:
-                    if opt != '__name__' and opt not in ignore_options:
-                        val = self._try_str(parser.get(section, opt))
-                        opt = opt.replace('-', '_')
-                        opt_dict[opt] = (filename, val)
-
-            # Make the ConfigParser forget everything (so we retain
-            # the original filenames that options come from)
-            parser.__init__()
-
-        # If there was a "global" section in the config file, use it
-        # to set Distribution options.
-
-        if 'global' in self.command_options:
-            for (opt, (src, val)) in self.command_options['global'].items():
-                alias = self.negative_opt.get(opt)
-                try:
-                    if alias:
-                        setattr(self, alias, not strtobool(val))
-                    elif opt in ('verbose', 'dry_run'):  # ugh!
-                        setattr(self, opt, strtobool(val))
-                    else:
-                        setattr(self, opt, val)
-                except ValueError as msg:
-                    raise DistutilsOptionError(msg)
-
-    @staticmethod
-    def _try_str(val):
-        """
-        On Python 2, much of distutils relies on string values being of
-        type 'str' (bytes) and not unicode text. If the value can be safely
-        encoded to bytes using the default encoding, prefer that.
-
-        Why the default encoding? Because that value can be implicitly
-        decoded back to text if needed.
-
-        Ref #1653
-        """
-        if not six.PY2:
-            return val
-        try:
-            return val.encode()
-        except UnicodeEncodeError:
-            pass
-        return val
-
-    def _set_command_options(self, command_obj, option_dict=None):
-        """
-        Set the options for 'command_obj' from 'option_dict'.  Basically
-        this means copying elements of a dictionary ('option_dict') to
-        attributes of an instance ('command').
-
-        'command_obj' must be a Command instance.  If 'option_dict' is not
-        supplied, uses the standard option dictionary for this command
-        (from 'self.command_options').
-
-        (Adopted from distutils.dist.Distribution._set_command_options)
-        """
-        command_name = command_obj.get_command_name()
-        if option_dict is None:
-            option_dict = self.get_option_dict(command_name)
-
-        if DEBUG:
-            self.announce("  setting options for '%s' command:" % command_name)
-        for (option, (source, value)) in option_dict.items():
-            if DEBUG:
-                self.announce("    %s = %s (from %s)" % (option, value,
-                                                         source))
-            try:
-                bool_opts = [translate_longopt(o)
-                             for o in command_obj.boolean_options]
-            except AttributeError:
-                bool_opts = []
-            try:
-                neg_opt = command_obj.negative_opt
-            except AttributeError:
-                neg_opt = {}
-
-            try:
-                is_string = isinstance(value, six.string_types)
-                if option in neg_opt and is_string:
-                    setattr(command_obj, neg_opt[option], not strtobool(value))
-                elif option in bool_opts and is_string:
-                    setattr(command_obj, option, strtobool(value))
-                elif hasattr(command_obj, option):
-                    setattr(command_obj, option, value)
-                else:
-                    raise DistutilsOptionError(
-                        "error in %s: command '%s' has no such option '%s'"
-                        % (source, command_name, option))
-            except ValueError as msg:
-                raise DistutilsOptionError(msg)
-
-    def parse_config_files(self, filenames=None, ignore_option_errors=False):
+        if getattr(self, 'extras_require', None): 
+            for extra in self.extras_require.keys(): 
+                # Since this gets called multiple times at points where the 
+                # keys have become 'converted' extras, ensure that we are only 
+                # truly adding extras we haven't seen before here. 
+                extra = extra.split(':')[0] 
+                if extra: 
+                    self.metadata.provides_extras.add(extra) 
+ 
+        self._convert_extras_requirements() 
+        self._move_install_requirements_markers() 
+ 
+    def _convert_extras_requirements(self): 
+        """ 
+        Convert requirements in `extras_require` of the form 
+        `"extra": ["barbazquux; {marker}"]` to 
+        `"extra:{marker}": ["barbazquux"]`. 
+        """ 
+        spec_ext_reqs = getattr(self, 'extras_require', None) or {} 
+        self._tmp_extras_require = defaultdict(list) 
+        for section, v in spec_ext_reqs.items(): 
+            # Do not strip empty sections. 
+            self._tmp_extras_require[section] 
+            for r in pkg_resources.parse_requirements(v): 
+                suffix = self._suffix_for(r) 
+                self._tmp_extras_require[section + suffix].append(r) 
+ 
+    @staticmethod 
+    def _suffix_for(req): 
+        """ 
+        For a requirement, return the 'extras_require' suffix for 
+        that requirement. 
+        """ 
+        return ':' + str(req.marker) if req.marker else '' 
+ 
+    def _move_install_requirements_markers(self): 
+        """ 
+        Move requirements in `install_requires` that are using environment 
+        markers `extras_require`. 
+        """ 
+ 
+        # divide the install_requires into two sets, simple ones still 
+        # handled by install_requires and more complex ones handled 
+        # by extras_require. 
+ 
+        def is_simple_req(req): 
+            return not req.marker 
+ 
+        spec_inst_reqs = getattr(self, 'install_requires', None) or () 
+        inst_reqs = list(pkg_resources.parse_requirements(spec_inst_reqs)) 
+        simple_reqs = filter(is_simple_req, inst_reqs) 
+        complex_reqs = filterfalse(is_simple_req, inst_reqs) 
+        self.install_requires = list(map(str, simple_reqs)) 
+ 
+        for r in complex_reqs: 
+            self._tmp_extras_require[':' + str(r.marker)].append(r) 
+        self.extras_require = dict( 
+            (k, [str(r) for r in map(self._clean_req, v)]) 
+            for k, v in self._tmp_extras_require.items() 
+        ) 
+ 
+    def _clean_req(self, req): 
+        """ 
+        Given a Requirement, remove environment markers and return it. 
+        """ 
+        req.marker = None 
+        return req 
+ 
+    def _parse_config_files(self, filenames=None): 
+        """ 
+        Adapted from distutils.dist.Distribution.parse_config_files, 
+        this method provides the same functionality in subtly-improved 
+        ways. 
+        """ 
+        from setuptools.extern.six.moves.configparser import ConfigParser 
+ 
+        # Ignore install directory options if we have a venv 
+        if not six.PY2 and sys.prefix != sys.base_prefix: 
+            ignore_options = [ 
+                'install-base', 'install-platbase', 'install-lib', 
+                'install-platlib', 'install-purelib', 'install-headers', 
+                'install-scripts', 'install-data', 'prefix', 'exec-prefix', 
+                'home', 'user', 'root'] 
+        else: 
+            ignore_options = [] 
+ 
+        ignore_options = frozenset(ignore_options) 
+ 
+        if filenames is None: 
+            filenames = self.find_config_files() 
+ 
+        if DEBUG: 
+            self.announce("Distribution.parse_config_files():") 
+ 
+        parser = ConfigParser() 
+        for filename in filenames: 
+            with io.open(filename, encoding='utf-8') as reader: 
+                if DEBUG: 
+                    self.announce("  reading {filename}".format(**locals())) 
+                (parser.readfp if six.PY2 else parser.read_file)(reader) 
+            for section in parser.sections(): 
+                options = parser.options(section) 
+                opt_dict = self.get_option_dict(section) 
+ 
+                for opt in options: 
+                    if opt != '__name__' and opt not in ignore_options: 
+                        val = self._try_str(parser.get(section, opt)) 
+                        opt = opt.replace('-', '_') 
+                        opt_dict[opt] = (filename, val) 
+ 
+            # Make the ConfigParser forget everything (so we retain 
+            # the original filenames that options come from) 
+            parser.__init__() 
+ 
+        # If there was a "global" section in the config file, use it 
+        # to set Distribution options. 
+ 
+        if 'global' in self.command_options: 
+            for (opt, (src, val)) in self.command_options['global'].items(): 
+                alias = self.negative_opt.get(opt) 
+                try: 
+                    if alias: 
+                        setattr(self, alias, not strtobool(val)) 
+                    elif opt in ('verbose', 'dry_run'):  # ugh! 
+                        setattr(self, opt, strtobool(val)) 
+                    else: 
+                        setattr(self, opt, val) 
+                except ValueError as msg: 
+                    raise DistutilsOptionError(msg) 
+ 
+    @staticmethod 
+    def _try_str(val): 
+        """ 
+        On Python 2, much of distutils relies on string values being of 
+        type 'str' (bytes) and not unicode text. If the value can be safely 
+        encoded to bytes using the default encoding, prefer that. 
+ 
+        Why the default encoding? Because that value can be implicitly 
+        decoded back to text if needed. 
+ 
+        Ref #1653 
+        """ 
+        if not six.PY2: 
+            return val 
+        try: 
+            return val.encode() 
+        except UnicodeEncodeError: 
+            pass 
+        return val 
+ 
+    def _set_command_options(self, command_obj, option_dict=None): 
+        """ 
+        Set the options for 'command_obj' from 'option_dict'.  Basically 
+        this means copying elements of a dictionary ('option_dict') to 
+        attributes of an instance ('command'). 
+ 
+        'command_obj' must be a Command instance.  If 'option_dict' is not 
+        supplied, uses the standard option dictionary for this command 
+        (from 'self.command_options'). 
+ 
+        (Adopted from distutils.dist.Distribution._set_command_options) 
+        """ 
+        command_name = command_obj.get_command_name() 
+        if option_dict is None: 
+            option_dict = self.get_option_dict(command_name) 
+ 
+        if DEBUG: 
+            self.announce("  setting options for '%s' command:" % command_name) 
+        for (option, (source, value)) in option_dict.items(): 
+            if DEBUG: 
+                self.announce("    %s = %s (from %s)" % (option, value, 
+                                                         source)) 
+            try: 
+                bool_opts = [translate_longopt(o) 
+                             for o in command_obj.boolean_options] 
+            except AttributeError: 
+                bool_opts = [] 
+            try: 
+                neg_opt = command_obj.negative_opt 
+            except AttributeError: 
+                neg_opt = {} 
+ 
+            try: 
+                is_string = isinstance(value, six.string_types) 
+                if option in neg_opt and is_string: 
+                    setattr(command_obj, neg_opt[option], not strtobool(value)) 
+                elif option in bool_opts and is_string: 
+                    setattr(command_obj, option, strtobool(value)) 
+                elif hasattr(command_obj, option): 
+                    setattr(command_obj, option, value) 
+                else: 
+                    raise DistutilsOptionError( 
+                        "error in %s: command '%s' has no such option '%s'" 
+                        % (source, command_name, option)) 
+            except ValueError as msg: 
+                raise DistutilsOptionError(msg) 
+ 
+    def parse_config_files(self, filenames=None, ignore_option_errors=False): 
         """Parses configuration files from various levels
         and loads configuration.
 
         """
-        self._parse_config_files(filenames=filenames)
+        self._parse_config_files(filenames=filenames) 
 
-        parse_configuration(self, self.command_options,
-                            ignore_option_errors=ignore_option_errors)
-        self._finalize_requires()
+        parse_configuration(self, self.command_options, 
+                            ignore_option_errors=ignore_option_errors) 
+        self._finalize_requires() 
 
     def parse_command_line(self):
         """Process features after parsing command line options"""
@@ -725,34 +725,34 @@ class Distribution(_Distribution):
         return resolved_dists
 
     def finalize_options(self):
-        """
-        Allow plugins to apply arbitrary operations to the
-        distribution. Each hook may optionally define a 'order'
-        to influence the order of execution. Smaller numbers
-        go first and the default is 0.
-        """
-        group = 'setuptools.finalize_distribution_options'
-
-        def by_order(hook):
-            return getattr(hook, 'order', 0)
-        eps = map(lambda e: e.load(), pkg_resources.iter_entry_points(group))
-        for ep in sorted(eps, key=by_order):
-            ep(self)
-
-    def _finalize_setup_keywords(self):
+        """ 
+        Allow plugins to apply arbitrary operations to the 
+        distribution. Each hook may optionally define a 'order' 
+        to influence the order of execution. Smaller numbers 
+        go first and the default is 0. 
+        """ 
+        group = 'setuptools.finalize_distribution_options' 
+
+        def by_order(hook): 
+            return getattr(hook, 'order', 0) 
+        eps = map(lambda e: e.load(), pkg_resources.iter_entry_points(group)) 
+        for ep in sorted(eps, key=by_order): 
+            ep(self) 
+ 
+    def _finalize_setup_keywords(self): 
         for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
             value = getattr(self, ep.name, None)
             if value is not None:
                 ep.require(installer=self.fetch_build_egg)
                 ep.load()(self, ep.name, value)
-
-    def _finalize_2to3_doctests(self):
+ 
+    def _finalize_2to3_doctests(self): 
         if getattr(self, 'convert_2to3_doctests', None):
             # XXX may convert to set here when we can rely on set being builtin
-            self.convert_2to3_doctests = [
-                os.path.abspath(p)
-                for p in self.convert_2to3_doctests
-            ]
+            self.convert_2to3_doctests = [ 
+                os.path.abspath(p) 
+                for p in self.convert_2to3_doctests 
+            ] 
         else:
             self.convert_2to3_doctests = []
 
@@ -773,15 +773,15 @@ class Distribution(_Distribution):
 
     def fetch_build_egg(self, req):
         """Fetch an egg needed for building"""
-        from setuptools.installer import fetch_build_egg
-        return fetch_build_egg(self, req)
+        from setuptools.installer import fetch_build_egg 
+        return fetch_build_egg(self, req) 
 
-    def _finalize_feature_opts(self):
+    def _finalize_feature_opts(self): 
         """Add --with-X/--without-X options based on optional features"""
 
-        if not self.features:
-            return
-
+        if not self.features: 
+            return 
+ 
         go = []
         no = self.negative_opt.copy()
 
@@ -796,11 +796,11 @@ class Distribution(_Distribution):
                 if not feature.include_by_default():
                     excdef, incdef = incdef, excdef
 
-                new = (
-                    ('with-' + name, None, 'include ' + descr + incdef),
-                    ('without-' + name, None, 'exclude ' + descr + excdef),
-                )
-                go.extend(new)
+                new = ( 
+                    ('with-' + name, None, 'include ' + descr + incdef), 
+                    ('without-' + name, None, 'exclude ' + descr + excdef), 
+                ) 
+                go.extend(new) 
                 no['without-' + name] = 'with-' + name
 
         self.global_options = self.feature_options = go + self.global_options
@@ -828,8 +828,8 @@ class Distribution(_Distribution):
         if command in self.cmdclass:
             return self.cmdclass[command]
 
-        eps = pkg_resources.iter_entry_points('distutils.commands', command)
-        for ep in eps:
+        eps = pkg_resources.iter_entry_points('distutils.commands', command) 
+        for ep in eps: 
             ep.require(installer=self.fetch_build_egg)
             self.cmdclass[command] = cmdclass = ep.load()
             return cmdclass
@@ -874,7 +874,7 @@ class Distribution(_Distribution):
     def include(self, **attrs):
         """Add items to distribution that are named in keyword arguments
 
-        For example, 'dist.include(py_modules=["x"])' would add 'x' to
+        For example, 'dist.include(py_modules=["x"])' would add 'x' to 
         the distribution's 'py_modules' attribute, if it was not already
         there.
 
@@ -963,8 +963,8 @@ class Distribution(_Distribution):
                 name + ": this setting cannot be changed via include/exclude"
             )
         else:
-            new = [item for item in value if item not in old]
-            setattr(self, name, old + new)
+            new = [item for item in value if item not in old] 
+            setattr(self, name, old + new) 
 
     def exclude(self, **attrs):
         """Remove items from distribution that are named in keyword arguments
@@ -1174,14 +1174,14 @@ class Feature:
 
     @staticmethod
     def warn_deprecated():
-        msg = (
+        msg = ( 
             "Features are deprecated and will be removed in a future "
-            "version. See https://github.com/pypa/setuptools/issues/65."
+            "version. See https://github.com/pypa/setuptools/issues/65." 
         )
-        warnings.warn(msg, DistDeprecationWarning, stacklevel=3)
+        warnings.warn(msg, DistDeprecationWarning, stacklevel=3) 
 
-    def __init__(
-            self, description, standard=False, available=True,
+    def __init__( 
+            self, description, standard=False, available=True, 
             optional=True, require_features=(), remove=(), **extras):
         self.warn_deprecated()
 
@@ -1206,8 +1206,8 @@ class Feature:
 
         if not remove and not require_features and not extras:
             raise DistutilsSetupError(
-                "Feature %s: must define 'require_features', 'remove', or "
-                "at least one of 'packages', 'py_modules', etc."
+                "Feature %s: must define 'require_features', 'remove', or " 
+                "at least one of 'packages', 'py_modules', etc." 
             )
 
     def include_by_default(self):
@@ -1267,8 +1267,8 @@ class Feature:
                     " doesn't contain any packages or modules under %s"
                     % (self.description, item, item)
                 )
-
-
-class DistDeprecationWarning(SetuptoolsDeprecationWarning):
-    """Class for warning about deprecations in dist in
-    setuptools. Not ignored by default, unlike DeprecationWarning."""
+ 
+ 
+class DistDeprecationWarning(SetuptoolsDeprecationWarning): 
+    """Class for warning about deprecations in dist in 
+    setuptools. Not ignored by default, unlike DeprecationWarning.""" 
diff --git a/contrib/python/setuptools/py2/setuptools/errors.py b/contrib/python/setuptools/py2/setuptools/errors.py
index 2701747f56..7228358278 100644
--- a/contrib/python/setuptools/py2/setuptools/errors.py
+++ b/contrib/python/setuptools/py2/setuptools/errors.py
@@ -1,16 +1,16 @@
-"""setuptools.errors
-
-Provides exceptions used by setuptools modules.
-"""
-
-from distutils.errors import DistutilsError
-
-
-class RemovedCommandError(DistutilsError, RuntimeError):
-    """Error used for commands that have been removed in setuptools.
-
-    Since ``setuptools`` is built on ``distutils``, simply removing a command
-    from ``setuptools`` will make the behavior fall back to ``distutils``; this
-    error is raised if a command exists in ``distutils`` but has been actively
-    removed in ``setuptools``.
-    """
+"""setuptools.errors 
+ 
+Provides exceptions used by setuptools modules. 
+""" 
+ 
+from distutils.errors import DistutilsError 
+ 
+ 
+class RemovedCommandError(DistutilsError, RuntimeError): 
+    """Error used for commands that have been removed in setuptools. 
+ 
+    Since ``setuptools`` is built on ``distutils``, simply removing a command 
+    from ``setuptools`` will make the behavior fall back to ``distutils``; this 
+    error is raised if a command exists in ``distutils`` but has been actively 
+    removed in ``setuptools``. 
+    """ 
diff --git a/contrib/python/setuptools/py2/setuptools/extension.py b/contrib/python/setuptools/py2/setuptools/extension.py
index 29468894f8..cdde7d9c21 100644
--- a/contrib/python/setuptools/py2/setuptools/extension.py
+++ b/contrib/python/setuptools/py2/setuptools/extension.py
@@ -4,7 +4,7 @@ import distutils.core
 import distutils.errors
 import distutils.extension
 
-from setuptools.extern.six.moves import map
+from setuptools.extern.six.moves import map 
 
 from .monkey import get_unpatched
 
diff --git a/contrib/python/setuptools/py2/setuptools/extern/__init__.py b/contrib/python/setuptools/py2/setuptools/extern/__init__.py
index e8c616f910..e667445e45 100644
--- a/contrib/python/setuptools/py2/setuptools/extern/__init__.py
+++ b/contrib/python/setuptools/py2/setuptools/extern/__init__.py
@@ -1,73 +1,73 @@
-import sys
-
-
-class VendorImporter:
-    """
-    A PEP 302 meta path importer for finding optionally-vendored
-    or otherwise naturally-installed packages from root_name.
-    """
-
-    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
-        self.root_name = root_name
-        self.vendored_names = set(vendored_names)
-        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
-
-    @property
-    def search_path(self):
-        """
-        Search first the vendor package then as a natural package.
-        """
-        yield self.vendor_pkg + '.'
-        yield ''
-
-    def find_module(self, fullname, path=None):
-        """
-        Return self when fullname starts with root_name and the
-        target module is one vendored through this importer.
-        """
-        root, base, target = fullname.partition(self.root_name + '.')
-        if root:
-            return
-        if not any(map(target.startswith, self.vendored_names)):
-            return
-        return self
-
-    def load_module(self, fullname):
-        """
-        Iterate over the search path to locate and load fullname.
-        """
-        root, base, target = fullname.partition(self.root_name + '.')
-        for prefix in self.search_path:
-            try:
-                extant = prefix + target
-                __import__(extant)
-                mod = sys.modules[extant]
-                sys.modules[fullname] = mod
-                # mysterious hack:
-                # Remove the reference to the extant package/module
-                # on later Python versions to cause relative imports
-                # in the vendor package to resolve the same modules
-                # as those going through this importer.
-                if sys.version_info >= (3, ):
-                    del sys.modules[extant]
-                return mod
-            except ImportError:
-                pass
-        else:
-            raise ImportError(
-                "The '{target}' package is required; "
-                "normally this is bundled with this package so if you get "
-                "this warning, consult the packager of your "
-                "distribution.".format(**locals())
-            )
-
-    def install(self):
-        """
-        Install this importer into sys.meta_path if not already present.
-        """
-        if self not in sys.meta_path:
-            sys.meta_path.append(self)
-
-
-names = 'six', 'packaging', 'pyparsing', 'ordered_set',
-VendorImporter(__name__, names, 'setuptools._vendor').install()
+import sys 
+ 
+ 
+class VendorImporter: 
+    """ 
+    A PEP 302 meta path importer for finding optionally-vendored 
+    or otherwise naturally-installed packages from root_name. 
+    """ 
+ 
+    def __init__(self, root_name, vendored_names=(), vendor_pkg=None): 
+        self.root_name = root_name 
+        self.vendored_names = set(vendored_names) 
+        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor') 
+ 
+    @property 
+    def search_path(self): 
+        """ 
+        Search first the vendor package then as a natural package. 
+        """ 
+        yield self.vendor_pkg + '.' 
+        yield '' 
+ 
+    def find_module(self, fullname, path=None): 
+        """ 
+        Return self when fullname starts with root_name and the 
+        target module is one vendored through this importer. 
+        """ 
+        root, base, target = fullname.partition(self.root_name + '.') 
+        if root: 
+            return 
+        if not any(map(target.startswith, self.vendored_names)): 
+            return 
+        return self 
+ 
+    def load_module(self, fullname): 
+        """ 
+        Iterate over the search path to locate and load fullname. 
+        """ 
+        root, base, target = fullname.partition(self.root_name + '.') 
+        for prefix in self.search_path: 
+            try: 
+                extant = prefix + target 
+                __import__(extant) 
+                mod = sys.modules[extant] 
+                sys.modules[fullname] = mod 
+                # mysterious hack: 
+                # Remove the reference to the extant package/module 
+                # on later Python versions to cause relative imports 
+                # in the vendor package to resolve the same modules 
+                # as those going through this importer. 
+                if sys.version_info >= (3, ): 
+                    del sys.modules[extant] 
+                return mod 
+            except ImportError: 
+                pass 
+        else: 
+            raise ImportError( 
+                "The '{target}' package is required; " 
+                "normally this is bundled with this package so if you get " 
+                "this warning, consult the packager of your " 
+                "distribution.".format(**locals()) 
+            ) 
+ 
+    def install(self): 
+        """ 
+        Install this importer into sys.meta_path if not already present. 
+        """ 
+        if self not in sys.meta_path: 
+            sys.meta_path.append(self) 
+ 
+ 
+names = 'six', 'packaging', 'pyparsing', 'ordered_set', 
+VendorImporter(__name__, names, 'setuptools._vendor').install() 
diff --git a/contrib/python/setuptools/py2/setuptools/glob.py b/contrib/python/setuptools/py2/setuptools/glob.py
index 9d7cbc5da6..3c28330688 100644
--- a/contrib/python/setuptools/py2/setuptools/glob.py
+++ b/contrib/python/setuptools/py2/setuptools/glob.py
@@ -90,7 +90,7 @@ def _iglob(pathname, recursive):
 
 def glob1(dirname, pattern):
     if not dirname:
-        if isinstance(pattern, bytes):
+        if isinstance(pattern, bytes): 
             dirname = os.curdir.encode('ASCII')
         else:
             dirname = os.curdir
@@ -127,8 +127,8 @@ def glob2(dirname, pattern):
 # Recursively yields relative pathnames inside a literal directory.
 def _rlistdir(dirname):
     if not dirname:
-        if isinstance(dirname, bytes):
-            dirname = os.curdir.encode('ASCII')
+        if isinstance(dirname, bytes): 
+            dirname = os.curdir.encode('ASCII') 
         else:
             dirname = os.curdir
     try:
@@ -147,7 +147,7 @@ magic_check_bytes = re.compile(b'([*?[])')
 
 
 def has_magic(s):
-    if isinstance(s, bytes):
+    if isinstance(s, bytes): 
         match = magic_check_bytes.search(s)
     else:
         match = magic_check.search(s)
@@ -155,7 +155,7 @@ def has_magic(s):
 
 
 def _isrecursive(pattern):
-    if isinstance(pattern, bytes):
+    if isinstance(pattern, bytes): 
         return pattern == b'**'
     else:
         return pattern == '**'
@@ -167,7 +167,7 @@ def escape(pathname):
     # Escaping is done by wrapping any of "*?[" between square brackets.
     # Metacharacters do not work in the drive part and shouldn't be escaped.
     drive, pathname = os.path.splitdrive(pathname)
-    if isinstance(pathname, bytes):
+    if isinstance(pathname, bytes): 
         pathname = magic_check_bytes.sub(br'[\1]', pathname)
     else:
         pathname = magic_check.sub(r'[\1]', pathname)
diff --git a/contrib/python/setuptools/py2/setuptools/installer.py b/contrib/python/setuptools/py2/setuptools/installer.py
index 9f8be2ef84..a9246ba79c 100644
--- a/contrib/python/setuptools/py2/setuptools/installer.py
+++ b/contrib/python/setuptools/py2/setuptools/installer.py
@@ -1,150 +1,150 @@
-import glob
-import os
-import subprocess
-import sys
-from distutils import log
-from distutils.errors import DistutilsError
-
-import pkg_resources
-from setuptools.command.easy_install import easy_install
-from setuptools.extern import six
-from setuptools.wheel import Wheel
-
-from .py31compat import TemporaryDirectory
-
-
-def _fixup_find_links(find_links):
-    """Ensure find-links option end-up being a list of strings."""
-    if isinstance(find_links, six.string_types):
-        return find_links.split()
-    assert isinstance(find_links, (tuple, list))
-    return find_links
-
-
-def _legacy_fetch_build_egg(dist, req):
-    """Fetch an egg needed for building.
-
-    Legacy path using EasyInstall.
-    """
-    tmp_dist = dist.__class__({'script_args': ['easy_install']})
-    opts = tmp_dist.get_option_dict('easy_install')
-    opts.clear()
-    opts.update(
-        (k, v)
-        for k, v in dist.get_option_dict('easy_install').items()
-        if k in (
-            # don't use any other settings
-            'find_links', 'site_dirs', 'index_url',
-            'optimize', 'site_dirs', 'allow_hosts',
-        ))
-    if dist.dependency_links:
-        links = dist.dependency_links[:]
-        if 'find_links' in opts:
-            links = _fixup_find_links(opts['find_links'][1]) + links
-        opts['find_links'] = ('setup', links)
-    install_dir = dist.get_egg_cache_dir()
-    cmd = easy_install(
-        tmp_dist, args=["x"], install_dir=install_dir,
-        exclude_scripts=True,
-        always_copy=False, build_directory=None, editable=False,
-        upgrade=False, multi_version=True, no_report=True, user=False
-    )
-    cmd.ensure_finalized()
-    return cmd.easy_install(req)
-
-
-def fetch_build_egg(dist, req):
-    """Fetch an egg needed for building.
-
-    Use pip/wheel to fetch/build a wheel."""
-    # Check pip is available.
-    try:
-        pkg_resources.get_distribution('pip')
-    except pkg_resources.DistributionNotFound:
-        dist.announce(
-            'WARNING: The pip package is not available, falling back '
-            'to EasyInstall for handling setup_requires/test_requires; '
-            'this is deprecated and will be removed in a future version.'
-            , log.WARN
-        )
-        return _legacy_fetch_build_egg(dist, req)
-    # Warn if wheel is not.
-    try:
-        pkg_resources.get_distribution('wheel')
-    except pkg_resources.DistributionNotFound:
-        dist.announce('WARNING: The wheel package is not available.', log.WARN)
-    # Ignore environment markers; if supplied, it is required.
-    req = strip_marker(req)
-    # Take easy_install options into account, but do not override relevant
-    # pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll
-    # take precedence.
-    opts = dist.get_option_dict('easy_install')
-    if 'allow_hosts' in opts:
-        raise DistutilsError('the `allow-hosts` option is not supported '
-                             'when using pip to install requirements.')
-    if 'PIP_QUIET' in os.environ or 'PIP_VERBOSE' in os.environ:
-        quiet = False
-    else:
-        quiet = True
-    if 'PIP_INDEX_URL' in os.environ:
-        index_url = None
-    elif 'index_url' in opts:
-        index_url = opts['index_url'][1]
-    else:
-        index_url = None
-    if 'find_links' in opts:
-        find_links = _fixup_find_links(opts['find_links'][1])[:]
-    else:
-        find_links = []
-    if dist.dependency_links:
-        find_links.extend(dist.dependency_links)
-    eggs_dir = os.path.realpath(dist.get_egg_cache_dir())
-    environment = pkg_resources.Environment()
-    for egg_dist in pkg_resources.find_distributions(eggs_dir):
-        if egg_dist in req and environment.can_add(egg_dist):
-            return egg_dist
-    with TemporaryDirectory() as tmpdir:
-        cmd = [
-            sys.executable, '-m', 'pip',
-            '--disable-pip-version-check',
-            'wheel', '--no-deps',
-            '-w', tmpdir,
-        ]
-        if quiet:
-            cmd.append('--quiet')
-        if index_url is not None:
-            cmd.extend(('--index-url', index_url))
-        if find_links is not None:
-            for link in find_links:
-                cmd.extend(('--find-links', link))
-        # If requirement is a PEP 508 direct URL, directly pass
-        # the URL to pip, as `req @ url` does not work on the
-        # command line.
-        if req.url:
-            cmd.append(req.url)
-        else:
-            cmd.append(str(req))
-        try:
-            subprocess.check_call(cmd)
-        except subprocess.CalledProcessError as e:
-            raise DistutilsError(str(e))
-        wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0])
-        dist_location = os.path.join(eggs_dir, wheel.egg_name())
-        wheel.install_as_egg(dist_location)
-        dist_metadata = pkg_resources.PathMetadata(
-            dist_location, os.path.join(dist_location, 'EGG-INFO'))
-        dist = pkg_resources.Distribution.from_filename(
-            dist_location, metadata=dist_metadata)
-        return dist
-
-
-def strip_marker(req):
-    """
-    Return a new requirement without the environment marker to avoid
-    calling pip with something like `babel; extra == "i18n"`, which
-    would always be ignored.
-    """
-    # create a copy to avoid mutating the input
-    req = pkg_resources.Requirement.parse(str(req))
-    req.marker = None
-    return req
+import glob 
+import os 
+import subprocess 
+import sys 
+from distutils import log 
+from distutils.errors import DistutilsError 
+ 
+import pkg_resources 
+from setuptools.command.easy_install import easy_install 
+from setuptools.extern import six 
+from setuptools.wheel import Wheel 
+ 
+from .py31compat import TemporaryDirectory 
+ 
+ 
+def _fixup_find_links(find_links): 
+    """Ensure find-links option end-up being a list of strings.""" 
+    if isinstance(find_links, six.string_types): 
+        return find_links.split() 
+    assert isinstance(find_links, (tuple, list)) 
+    return find_links 
+ 
+ 
+def _legacy_fetch_build_egg(dist, req): 
+    """Fetch an egg needed for building. 
+ 
+    Legacy path using EasyInstall. 
+    """ 
+    tmp_dist = dist.__class__({'script_args': ['easy_install']}) 
+    opts = tmp_dist.get_option_dict('easy_install') 
+    opts.clear() 
+    opts.update( 
+        (k, v) 
+        for k, v in dist.get_option_dict('easy_install').items() 
+        if k in ( 
+            # don't use any other settings 
+            'find_links', 'site_dirs', 'index_url', 
+            'optimize', 'site_dirs', 'allow_hosts', 
+        )) 
+    if dist.dependency_links: 
+        links = dist.dependency_links[:] 
+        if 'find_links' in opts: 
+            links = _fixup_find_links(opts['find_links'][1]) + links 
+        opts['find_links'] = ('setup', links) 
+    install_dir = dist.get_egg_cache_dir() 
+    cmd = easy_install( 
+        tmp_dist, args=["x"], install_dir=install_dir, 
+        exclude_scripts=True, 
+        always_copy=False, build_directory=None, editable=False, 
+        upgrade=False, multi_version=True, no_report=True, user=False 
+    ) 
+    cmd.ensure_finalized() 
+    return cmd.easy_install(req) 
+ 
+ 
+def fetch_build_egg(dist, req): 
+    """Fetch an egg needed for building. 
+ 
+    Use pip/wheel to fetch/build a wheel.""" 
+    # Check pip is available. 
+    try: 
+        pkg_resources.get_distribution('pip') 
+    except pkg_resources.DistributionNotFound: 
+        dist.announce( 
+            'WARNING: The pip package is not available, falling back ' 
+            'to EasyInstall for handling setup_requires/test_requires; ' 
+            'this is deprecated and will be removed in a future version.' 
+            , log.WARN 
+        ) 
+        return _legacy_fetch_build_egg(dist, req) 
+    # Warn if wheel is not. 
+    try: 
+        pkg_resources.get_distribution('wheel') 
+    except pkg_resources.DistributionNotFound: 
+        dist.announce('WARNING: The wheel package is not available.', log.WARN) 
+    # Ignore environment markers; if supplied, it is required. 
+    req = strip_marker(req) 
+    # Take easy_install options into account, but do not override relevant 
+    # pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll 
+    # take precedence. 
+    opts = dist.get_option_dict('easy_install') 
+    if 'allow_hosts' in opts: 
+        raise DistutilsError('the `allow-hosts` option is not supported ' 
+                             'when using pip to install requirements.') 
+    if 'PIP_QUIET' in os.environ or 'PIP_VERBOSE' in os.environ: 
+        quiet = False 
+    else: 
+        quiet = True 
+    if 'PIP_INDEX_URL' in os.environ: 
+        index_url = None 
+    elif 'index_url' in opts: 
+        index_url = opts['index_url'][1] 
+    else: 
+        index_url = None 
+    if 'find_links' in opts: 
+        find_links = _fixup_find_links(opts['find_links'][1])[:] 
+    else: 
+        find_links = [] 
+    if dist.dependency_links: 
+        find_links.extend(dist.dependency_links) 
+    eggs_dir = os.path.realpath(dist.get_egg_cache_dir()) 
+    environment = pkg_resources.Environment() 
+    for egg_dist in pkg_resources.find_distributions(eggs_dir): 
+        if egg_dist in req and environment.can_add(egg_dist): 
+            return egg_dist 
+    with TemporaryDirectory() as tmpdir: 
+        cmd = [ 
+            sys.executable, '-m', 'pip', 
+            '--disable-pip-version-check', 
+            'wheel', '--no-deps', 
+            '-w', tmpdir, 
+        ] 
+        if quiet: 
+            cmd.append('--quiet') 
+        if index_url is not None: 
+            cmd.extend(('--index-url', index_url)) 
+        if find_links is not None: 
+            for link in find_links: 
+                cmd.extend(('--find-links', link)) 
+        # If requirement is a PEP 508 direct URL, directly pass 
+        # the URL to pip, as `req @ url` does not work on the 
+        # command line. 
+        if req.url: 
+            cmd.append(req.url) 
+        else: 
+            cmd.append(str(req)) 
+        try: 
+            subprocess.check_call(cmd) 
+        except subprocess.CalledProcessError as e: 
+            raise DistutilsError(str(e)) 
+        wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0]) 
+        dist_location = os.path.join(eggs_dir, wheel.egg_name()) 
+        wheel.install_as_egg(dist_location) 
+        dist_metadata = pkg_resources.PathMetadata( 
+            dist_location, os.path.join(dist_location, 'EGG-INFO')) 
+        dist = pkg_resources.Distribution.from_filename( 
+            dist_location, metadata=dist_metadata) 
+        return dist 
+ 
+ 
+def strip_marker(req): 
+    """ 
+    Return a new requirement without the environment marker to avoid 
+    calling pip with something like `babel; extra == "i18n"`, which 
+    would always be ignored. 
+    """ 
+    # create a copy to avoid mutating the input 
+    req = pkg_resources.Requirement.parse(str(req)) 
+    req.marker = None 
+    return req 
diff --git a/contrib/python/setuptools/py2/setuptools/monkey.py b/contrib/python/setuptools/py2/setuptools/monkey.py
index 3c77f8cf27..123dc28981 100644
--- a/contrib/python/setuptools/py2/setuptools/monkey.py
+++ b/contrib/python/setuptools/py2/setuptools/monkey.py
@@ -7,10 +7,10 @@ import distutils.filelist
 import platform
 import types
 import functools
-from importlib import import_module
+from importlib import import_module 
 import inspect
 
-from setuptools.extern import six
+from setuptools.extern import six 
 
 import setuptools
 
@@ -21,20 +21,20 @@ if you think you need this functionality.
 """
 
 
-def _get_mro(cls):
-    """
-    Returns the bases classes for cls sorted by the MRO.
-
-    Works around an issue on Jython where inspect.getmro will not return all
-    base classes if multiple classes share the same name. Instead, this
-    function will return a tuple containing the class itself, and the contents
-    of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024.
-    """
-    if platform.python_implementation() == "Jython":
-        return (cls,) + cls.__bases__
-    return inspect.getmro(cls)
-
-
+def _get_mro(cls): 
+    """ 
+    Returns the bases classes for cls sorted by the MRO. 
+ 
+    Works around an issue on Jython where inspect.getmro will not return all 
+    base classes if multiple classes share the same name. Instead, this 
+    function will return a tuple containing the class itself, and the contents 
+    of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024. 
+    """ 
+    if platform.python_implementation() == "Jython": 
+        return (cls,) + cls.__bases__ 
+    return inspect.getmro(cls) 
+ 
+ 
 def get_unpatched(item):
     lookup = (
         get_unpatched_class if isinstance(item, six.class_types) else
@@ -52,7 +52,7 @@ def get_unpatched_class(cls):
     """
     external_bases = (
         cls
-        for cls in _get_mro(cls)
+        for cls in _get_mro(cls) 
         if not cls.__module__.startswith('setuptools')
     )
     base = next(external_bases)
@@ -84,7 +84,7 @@ def patch_all():
         warehouse = 'https://upload.pypi.org/legacy/'
         distutils.config.PyPIRCCommand.DEFAULT_REPOSITORY = warehouse
 
-    _patch_distribution_metadata()
+    _patch_distribution_metadata() 
 
     # Install Distribution throughout the distutils
     for module in distutils.dist, distutils.core, distutils.cmd:
@@ -101,11 +101,11 @@ def patch_all():
     patch_for_msvc_specialized_compiler()
 
 
-def _patch_distribution_metadata():
-    """Patch write_pkg_file and read_pkg_file for higher metadata standards"""
-    for attr in ('write_pkg_file', 'read_pkg_file', 'get_metadata_version'):
-        new_val = getattr(setuptools.dist, attr)
-        setattr(distutils.dist.DistributionMetadata, attr, new_val)
+def _patch_distribution_metadata(): 
+    """Patch write_pkg_file and read_pkg_file for higher metadata standards""" 
+    for attr in ('write_pkg_file', 'read_pkg_file', 'get_metadata_version'): 
+        new_val = getattr(setuptools.dist, attr) 
+        setattr(distutils.dist.DistributionMetadata, attr, new_val) 
 
 
 def patch_func(replacement, target_mod, func_name):
diff --git a/contrib/python/setuptools/py2/setuptools/msvc.py b/contrib/python/setuptools/py2/setuptools/msvc.py
index 2ffe1c81ee..e7ba7afb64 100644
--- a/contrib/python/setuptools/py2/setuptools/msvc.py
+++ b/contrib/python/setuptools/py2/setuptools/msvc.py
@@ -4,40 +4,40 @@ Improved support for Microsoft Visual C++ compilers.
 Known supported compilers:
 --------------------------
 Microsoft Visual C++ 9.0:
-    Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
+    Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64) 
     Microsoft Windows SDK 6.1 (x86, x64, ia64)
-    Microsoft Windows SDK 7.0 (x86, x64, ia64)
+    Microsoft Windows SDK 7.0 (x86, x64, ia64) 
 
 Microsoft Visual C++ 10.0:
     Microsoft Windows SDK 7.1 (x86, x64, ia64)
 
-Microsoft Visual C++ 14.X:
+Microsoft Visual C++ 14.X: 
     Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
-    Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
-    Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64)
-
-This may also support compilers shipped with compatible Visual Studio versions.
+    Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64) 
+    Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64) 
+ 
+This may also support compilers shipped with compatible Visual Studio versions. 
 """
 
-import json
-from io import open
-from os import listdir, pathsep
-from os.path import join, isfile, isdir, dirname
+import json 
+from io import open 
+from os import listdir, pathsep 
+from os.path import join, isfile, isdir, dirname 
 import sys
 import platform
 import itertools
 import distutils.errors
-from setuptools.extern.packaging.version import LegacyVersion
+from setuptools.extern.packaging.version import LegacyVersion 
 
-from setuptools.extern.six.moves import filterfalse
+from setuptools.extern.six.moves import filterfalse 
 
 from .monkey import get_unpatched
 
 if platform.system() == 'Windows':
-    from setuptools.extern.six.moves import winreg
-    from os import environ
+    from setuptools.extern.six.moves import winreg 
+    from os import environ 
 else:
-    # Mock winreg and environ so the module can be imported on this platform.
+    # Mock winreg and environ so the module can be imported on this platform. 
 
     class winreg:
         HKEY_USERS = None
@@ -45,32 +45,32 @@ else:
         HKEY_LOCAL_MACHINE = None
         HKEY_CLASSES_ROOT = None
 
-    environ = dict()
-
-_msvc9_suppress_errors = (
-    # msvc9compiler isn't available on some platforms
-    ImportError,
-
-    # msvc9compiler raises DistutilsPlatformError in some
-    # environments. See #1118.
-    distutils.errors.DistutilsPlatformError,
-)
-
+    environ = dict() 
+
+_msvc9_suppress_errors = ( 
+    # msvc9compiler isn't available on some platforms 
+    ImportError, 
+ 
+    # msvc9compiler raises DistutilsPlatformError in some 
+    # environments. See #1118. 
+    distutils.errors.DistutilsPlatformError, 
+) 
+ 
 try:
     from distutils.msvc9compiler import Reg
-except _msvc9_suppress_errors:
+except _msvc9_suppress_errors: 
     pass
 
 
 def msvc9_find_vcvarsall(version):
     """
     Patched "distutils.msvc9compiler.find_vcvarsall" to use the standalone
-    compiler build for Python
-    (VCForPython / Microsoft Visual C++ Compiler for Python 2.7).
-
-    Fall back to original behavior when the standalone compiler is not
-    available.
+    compiler build for Python 
+    (VCForPython / Microsoft Visual C++ Compiler for Python 2.7). 
 
+    Fall back to original behavior when the standalone compiler is not 
+    available. 
+ 
     Redirect the path of "vcvarsall.bat".
 
     Parameters
@@ -80,25 +80,25 @@ def msvc9_find_vcvarsall(version):
 
     Return
     ------
-    str
-        vcvarsall.bat path
+    str 
+        vcvarsall.bat path 
     """
-    vc_base = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f'
-    key = vc_base % ('', version)
+    vc_base = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f' 
+    key = vc_base % ('', version) 
     try:
         # Per-user installs register the compiler path here
         productdir = Reg.get_value(key, "installdir")
     except KeyError:
         try:
             # All-user installs on a 64-bit system register here
-            key = vc_base % ('Wow6432Node\\', version)
+            key = vc_base % ('Wow6432Node\\', version) 
             productdir = Reg.get_value(key, "installdir")
         except KeyError:
             productdir = None
 
     if productdir:
-        vcvarsall = join(productdir, "vcvarsall.bat")
-        if isfile(vcvarsall):
+        vcvarsall = join(productdir, "vcvarsall.bat") 
+        if isfile(vcvarsall): 
             return vcvarsall
 
     return get_unpatched(msvc9_find_vcvarsall)(version)
@@ -106,8 +106,8 @@ def msvc9_find_vcvarsall(version):
 
 def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
     """
-    Patched "distutils.msvc9compiler.query_vcvarsall" for support extra
-    Microsoft Visual C++ 9.0 and 10.0 compilers.
+    Patched "distutils.msvc9compiler.query_vcvarsall" for support extra 
+    Microsoft Visual C++ 9.0 and 10.0 compilers. 
 
     Set environment without use of "vcvarsall.bat".
 
@@ -120,10 +120,10 @@ def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
 
     Return
     ------
-    dict
-        environment
+    dict 
+        environment 
     """
-    # Try to get environment from vcvarsall.bat (Classical way)
+    # Try to get environment from vcvarsall.bat (Classical way) 
     try:
         orig = get_unpatched(msvc9_query_vcvarsall)
         return orig(ver, arch, *args, **kwargs)
@@ -144,8 +144,8 @@ def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
 
 def msvc14_get_vc_env(plat_spec):
     """
-    Patched "distutils._msvccompiler._get_vc_env" for support extra
-    Microsoft Visual C++ 14.X compilers.
+    Patched "distutils._msvccompiler._get_vc_env" for support extra 
+    Microsoft Visual C++ 14.X compilers. 
 
     Set environment without use of "vcvarsall.bat".
 
@@ -156,8 +156,8 @@ def msvc14_get_vc_env(plat_spec):
 
     Return
     ------
-    dict
-        environment
+    dict 
+        environment 
     """
     # Try to get environment from vcvarsall.bat (Classical way)
     try:
@@ -203,9 +203,9 @@ def _augment_exception(exc, version, arch=''):
         if version == 9.0:
             if arch.lower().find('ia64') > -1:
                 # For VC++ 9.0, if IA64 support is needed, redirect user
-                # to Windows SDK 7.0.
-                # Note: No download link available from Microsoft.
-                message += ' Get it with "Microsoft Windows SDK 7.0"'
+                # to Windows SDK 7.0. 
+                # Note: No download link available from Microsoft. 
+                message += ' Get it with "Microsoft Windows SDK 7.0"' 
             else:
                 # For VC++ 9.0 redirect user to Vc++ for Python 2.7 :
                 # This redirection link is maintained by Microsoft.
@@ -216,59 +216,59 @@ def _augment_exception(exc, version, arch=''):
             message += ' Get it with "Microsoft Windows SDK 7.1": '
             message += msdownload % 8279
         elif version >= 14.0:
-            # For VC++ 14.X Redirect user to latest Visual C++ Build Tools
-            message += (' Get it with "Build Tools for Visual Studio": '
-                        r'https://visualstudio.microsoft.com/downloads/')
+            # For VC++ 14.X Redirect user to latest Visual C++ Build Tools 
+            message += (' Get it with "Build Tools for Visual Studio": ' 
+                        r'https://visualstudio.microsoft.com/downloads/') 
 
     exc.args = (message, )
 
 
 class PlatformInfo:
     """
-    Current and Target Architectures information.
+    Current and Target Architectures information. 
 
     Parameters
     ----------
     arch: str
         Target architecture.
     """
-    current_cpu = environ.get('processor_architecture', '').lower()
+    current_cpu = environ.get('processor_architecture', '').lower() 
 
     def __init__(self, arch):
         self.arch = arch.lower().replace('x64', 'amd64')
 
     @property
     def target_cpu(self):
-        """
-        Return Target CPU architecture.
-
-        Return
-        ------
-        str
-            Target CPU
-        """
+        """ 
+        Return Target CPU architecture. 
+ 
+        Return 
+        ------ 
+        str 
+            Target CPU 
+        """ 
         return self.arch[self.arch.find('_') + 1:]
 
     def target_is_x86(self):
-        """
-        Return True if target CPU is x86 32 bits..
-
-        Return
-        ------
-        bool
-            CPU is x86 32 bits
-        """
+        """ 
+        Return True if target CPU is x86 32 bits.. 
+ 
+        Return 
+        ------ 
+        bool 
+            CPU is x86 32 bits 
+        """ 
         return self.target_cpu == 'x86'
 
     def current_is_x86(self):
-        """
-        Return True if current CPU is x86 32 bits..
-
-        Return
-        ------
-        bool
-            CPU is x86 32 bits
-        """
+        """ 
+        Return True if current CPU is x86 32 bits.. 
+ 
+        Return 
+        ------ 
+        bool 
+            CPU is x86 32 bits 
+        """ 
         return self.current_cpu == 'x86'
 
     def current_dir(self, hidex86=False, x64=False):
@@ -284,8 +284,8 @@ class PlatformInfo:
 
         Return
         ------
-        str
-            subfolder: '\target', or '' (see hidex86 parameter)
+        str 
+            subfolder: '\target', or '' (see hidex86 parameter) 
         """
         return (
             '' if (self.current_cpu == 'x86' and hidex86) else
@@ -306,8 +306,8 @@ class PlatformInfo:
 
         Return
         ------
-        str
-            subfolder: '\current', or '' (see hidex86 parameter)
+        str 
+            subfolder: '\current', or '' (see hidex86 parameter) 
         """
         return (
             '' if (self.target_cpu == 'x86' and hidex86) else
@@ -322,13 +322,13 @@ class PlatformInfo:
         Parameters
         ----------
         forcex86: bool
-            Use 'x86' as current architecture even if current architecture is
+            Use 'x86' as current architecture even if current architecture is 
             not x86.
 
         Return
         ------
-        str
-            subfolder: '' if target architecture is current architecture,
+        str 
+            subfolder: '' if target architecture is current architecture, 
             '\current_target' if not.
         """
         current = 'x86' if forcex86 else self.current_cpu
@@ -340,7 +340,7 @@ class PlatformInfo:
 
 class RegistryInfo:
     """
-    Microsoft Visual Studio related registry information.
+    Microsoft Visual Studio related registry information. 
 
     Parameters
     ----------
@@ -359,11 +359,11 @@ class RegistryInfo:
     def visualstudio(self):
         """
         Microsoft Visual Studio root registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
         return 'VisualStudio'
 
@@ -371,47 +371,47 @@ class RegistryInfo:
     def sxs(self):
         """
         Microsoft Visual Studio SxS registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
-        return join(self.visualstudio, 'SxS')
+        return join(self.visualstudio, 'SxS') 
 
     @property
     def vc(self):
         """
         Microsoft Visual C++ VC7 registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
-        return join(self.sxs, 'VC7')
+        return join(self.sxs, 'VC7') 
 
     @property
     def vs(self):
         """
         Microsoft Visual Studio VS7 registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
-        return join(self.sxs, 'VS7')
+        return join(self.sxs, 'VS7') 
 
     @property
     def vc_for_python(self):
         """
         Microsoft Visual C++ for Python registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
         return r'DevDiv\VCForPython'
 
@@ -419,11 +419,11 @@ class RegistryInfo:
     def microsoft_sdk(self):
         """
         Microsoft SDK registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
         return 'Microsoft SDKs'
 
@@ -431,35 +431,35 @@ class RegistryInfo:
     def windows_sdk(self):
         """
         Microsoft Windows/Platform SDK registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
-        return join(self.microsoft_sdk, 'Windows')
+        return join(self.microsoft_sdk, 'Windows') 
 
     @property
     def netfx_sdk(self):
         """
         Microsoft .NET Framework SDK registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
-        return join(self.microsoft_sdk, 'NETFXSDK')
+        return join(self.microsoft_sdk, 'NETFXSDK') 
 
     @property
     def windows_kits_roots(self):
         """
         Microsoft Windows Kits Roots registry key.
-
-        Return
-        ------
-        str
-            Registry key
+ 
+        Return 
+        ------ 
+        str 
+            Registry key 
         """
         return r'Windows Kits\Installed Roots'
 
@@ -476,11 +476,11 @@ class RegistryInfo:
 
         Return
         ------
-        str
-            Registry key
+        str 
+            Registry key 
         """
-        node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node'
-        return join('Software', node64, 'Microsoft', key)
+        node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node' 
+        return join('Software', node64, 'Microsoft', key) 
 
     def lookup(self, key, name):
         """
@@ -495,19 +495,19 @@ class RegistryInfo:
 
         Return
         ------
-        str
-            value
+        str 
+            value 
         """
-        key_read = winreg.KEY_READ
+        key_read = winreg.KEY_READ 
         openkey = winreg.OpenKey
         ms = self.microsoft
         for hkey in self.HKEYS:
             try:
-                bkey = openkey(hkey, ms(key), 0, key_read)
+                bkey = openkey(hkey, ms(key), 0, key_read) 
             except (OSError, IOError):
                 if not self.pi.current_is_x86():
                     try:
-                        bkey = openkey(hkey, ms(key, True), 0, key_read)
+                        bkey = openkey(hkey, ms(key, True), 0, key_read) 
                     except (OSError, IOError):
                         continue
                 else:
@@ -520,7 +520,7 @@ class RegistryInfo:
 
 class SystemInfo:
     """
-    Microsoft Windows and Visual Studio related system information.
+    Microsoft Windows and Visual Studio related system information. 
 
     Parameters
     ----------
@@ -531,421 +531,421 @@ class SystemInfo:
     """
 
     # Variables and properties in this class use originals CamelCase variables
-    # names from Microsoft source files for more easy comparison.
-    WinDir = environ.get('WinDir', '')
-    ProgramFiles = environ.get('ProgramFiles', '')
-    ProgramFilesx86 = environ.get('ProgramFiles(x86)', ProgramFiles)
+    # names from Microsoft source files for more easy comparison. 
+    WinDir = environ.get('WinDir', '') 
+    ProgramFiles = environ.get('ProgramFiles', '') 
+    ProgramFilesx86 = environ.get('ProgramFiles(x86)', ProgramFiles) 
 
     def __init__(self, registry_info, vc_ver=None):
         self.ri = registry_info
         self.pi = self.ri.pi
 
-        self.known_vs_paths = self.find_programdata_vs_vers()
-
-        # Except for VS15+, VC version is aligned with VS version
-        self.vs_ver = self.vc_ver = (
-                vc_ver or self._find_latest_available_vs_ver())
-
-    def _find_latest_available_vs_ver(self):
-        """
-        Find the latest VC version
-
-        Return
-        ------
-        float
-            version
-        """
-        reg_vc_vers = self.find_reg_vs_vers()
-
-        if not (reg_vc_vers or self.known_vs_paths):
-            raise distutils.errors.DistutilsPlatformError(
-                'No Microsoft Visual C++ version found')
-
-        vc_vers = set(reg_vc_vers)
-        vc_vers.update(self.known_vs_paths)
-        return sorted(vc_vers)[-1]
-
-    def find_reg_vs_vers(self):
-        """
-        Find Microsoft Visual Studio versions available in registry.
-
-        Return
-        ------
-        list of float
-            Versions
-        """
-        ms = self.ri.microsoft
-        vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs)
-        vs_vers = []
+        self.known_vs_paths = self.find_programdata_vs_vers() 
+ 
+        # Except for VS15+, VC version is aligned with VS version 
+        self.vs_ver = self.vc_ver = ( 
+                vc_ver or self._find_latest_available_vs_ver()) 
+ 
+    def _find_latest_available_vs_ver(self): 
+        """
+        Find the latest VC version 
+ 
+        Return 
+        ------ 
+        float 
+            version 
+        """
+        reg_vc_vers = self.find_reg_vs_vers() 
+ 
+        if not (reg_vc_vers or self.known_vs_paths): 
+            raise distutils.errors.DistutilsPlatformError( 
+                'No Microsoft Visual C++ version found') 
+ 
+        vc_vers = set(reg_vc_vers) 
+        vc_vers.update(self.known_vs_paths) 
+        return sorted(vc_vers)[-1] 
+ 
+    def find_reg_vs_vers(self): 
+        """ 
+        Find Microsoft Visual Studio versions available in registry. 
+ 
+        Return 
+        ------ 
+        list of float 
+            Versions 
+        """ 
+        ms = self.ri.microsoft 
+        vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs) 
+        vs_vers = [] 
         for hkey in self.ri.HKEYS:
             for key in vckeys:
                 try:
-                    bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ)
+                    bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ) 
                 except (OSError, IOError):
                     continue
                 subkeys, values, _ = winreg.QueryInfoKey(bkey)
                 for i in range(values):
                     try:
                         ver = float(winreg.EnumValue(bkey, i)[0])
-                        if ver not in vs_vers:
-                            vs_vers.append(ver)
+                        if ver not in vs_vers: 
+                            vs_vers.append(ver) 
                     except ValueError:
                         pass
                 for i in range(subkeys):
                     try:
                         ver = float(winreg.EnumKey(bkey, i))
-                        if ver not in vs_vers:
-                            vs_vers.append(ver)
+                        if ver not in vs_vers: 
+                            vs_vers.append(ver) 
                     except ValueError:
                         pass
-        return sorted(vs_vers)
-
-    def find_programdata_vs_vers(self):
-        r"""
-        Find Visual studio 2017+ versions from information in
-        "C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances".
-
-        Return
-        ------
-        dict
-            float version as key, path as value.
-        """
-        vs_versions = {}
-        instances_dir = \
-            r'C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances'
-
-        try:
-            hashed_names = listdir(instances_dir)
-
-        except (OSError, IOError):
-            # Directory not exists with all Visual Studio versions
-            return vs_versions
-
-        for name in hashed_names:
-            try:
-                # Get VS installation path from "state.json" file
-                state_path = join(instances_dir, name, 'state.json')
-                with open(state_path, 'rt', encoding='utf-8') as state_file:
-                    state = json.load(state_file)
-                vs_path = state['installationPath']
-
-                # Raises OSError if this VS installation does not contain VC
-                listdir(join(vs_path, r'VC\Tools\MSVC'))
-
-                # Store version and path
-                vs_versions[self._as_float_version(
-                    state['installationVersion'])] = vs_path
-
-            except (OSError, IOError, KeyError):
-                # Skip if "state.json" file is missing or bad format
-                continue
-
-        return vs_versions
-
-    @staticmethod
-    def _as_float_version(version):
-        """
-        Return a string version as a simplified float version (major.minor)
-
-        Parameters
-        ----------
-        version: str
-            Version.
-
-        Return
-        ------
-        float
-            version
-        """
-        return float('.'.join(version.split('.')[:2]))
-
+        return sorted(vs_vers) 
+
+    def find_programdata_vs_vers(self): 
+        r""" 
+        Find Visual studio 2017+ versions from information in 
+        "C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances". 
+ 
+        Return 
+        ------ 
+        dict 
+            float version as key, path as value. 
+        """ 
+        vs_versions = {} 
+        instances_dir = \ 
+            r'C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances' 
+ 
+        try: 
+            hashed_names = listdir(instances_dir) 
+ 
+        except (OSError, IOError): 
+            # Directory not exists with all Visual Studio versions 
+            return vs_versions 
+ 
+        for name in hashed_names: 
+            try: 
+                # Get VS installation path from "state.json" file 
+                state_path = join(instances_dir, name, 'state.json') 
+                with open(state_path, 'rt', encoding='utf-8') as state_file: 
+                    state = json.load(state_file) 
+                vs_path = state['installationPath'] 
+ 
+                # Raises OSError if this VS installation does not contain VC 
+                listdir(join(vs_path, r'VC\Tools\MSVC')) 
+ 
+                # Store version and path 
+                vs_versions[self._as_float_version( 
+                    state['installationVersion'])] = vs_path 
+ 
+            except (OSError, IOError, KeyError): 
+                # Skip if "state.json" file is missing or bad format 
+                continue 
+ 
+        return vs_versions 
+ 
+    @staticmethod 
+    def _as_float_version(version): 
+        """ 
+        Return a string version as a simplified float version (major.minor) 
+ 
+        Parameters 
+        ---------- 
+        version: str 
+            Version. 
+ 
+        Return 
+        ------ 
+        float 
+            version 
+        """ 
+        return float('.'.join(version.split('.')[:2])) 
+ 
     @property
     def VSInstallDir(self):
         """
         Microsoft Visual Studio directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
         # Default path
-        default = join(self.ProgramFilesx86,
-                       'Microsoft Visual Studio %0.1f' % self.vs_ver)
+        default = join(self.ProgramFilesx86, 
+                       'Microsoft Visual Studio %0.1f' % self.vs_ver) 
 
         # Try to get path from registry, if fail use default path
-        return self.ri.lookup(self.ri.vs, '%0.1f' % self.vs_ver) or default
+        return self.ri.lookup(self.ri.vs, '%0.1f' % self.vs_ver) or default 
 
     @property
     def VCInstallDir(self):
         """
         Microsoft Visual C++ directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
-        path = self._guess_vc() or self._guess_vc_legacy()
+        path = self._guess_vc() or self._guess_vc_legacy() 
 
-        if not isdir(path):
+        if not isdir(path): 
             msg = 'Microsoft Visual C++ directory not found'
             raise distutils.errors.DistutilsPlatformError(msg)
 
         return path
 
-    def _guess_vc(self):
-        """
-        Locate Visual C++ for VS2017+.
-
-        Return
-        ------
-        str
-            path
-        """
-        if self.vs_ver <= 14.0:
-            return ''
-
-        try:
-            # First search in known VS paths
-            vs_dir = self.known_vs_paths[self.vs_ver]
-        except KeyError:
-            # Else, search with path from registry
-            vs_dir = self.VSInstallDir
-
-        guess_vc = join(vs_dir, r'VC\Tools\MSVC')
-
-        # Subdir with VC exact version as name
-        try:
-            # Update the VC version with real one instead of VS version
-            vc_ver = listdir(guess_vc)[-1]
-            self.vc_ver = self._as_float_version(vc_ver)
-            return join(guess_vc, vc_ver)
-        except (OSError, IOError, IndexError):
-            return ''
-
-    def _guess_vc_legacy(self):
-        """
-        Locate Visual C++ for versions prior to 2017.
-
-        Return
-        ------
-        str
-            path
-        """
-        default = join(self.ProgramFilesx86,
-                       r'Microsoft Visual Studio %0.1f\VC' % self.vs_ver)
-
-        # Try to get "VC++ for Python" path from registry as default path
-        reg_path = join(self.ri.vc_for_python, '%0.1f' % self.vs_ver)
-        python_vc = self.ri.lookup(reg_path, 'installdir')
-        default_vc = join(python_vc, 'VC') if python_vc else default
-
-        # Try to get path from registry, if fail use default path
-        return self.ri.lookup(self.ri.vc, '%0.1f' % self.vs_ver) or default_vc
-
+    def _guess_vc(self): 
+        """ 
+        Locate Visual C++ for VS2017+. 
+ 
+        Return 
+        ------ 
+        str 
+            path 
+        """ 
+        if self.vs_ver <= 14.0: 
+            return '' 
+ 
+        try: 
+            # First search in known VS paths 
+            vs_dir = self.known_vs_paths[self.vs_ver] 
+        except KeyError: 
+            # Else, search with path from registry 
+            vs_dir = self.VSInstallDir 
+ 
+        guess_vc = join(vs_dir, r'VC\Tools\MSVC') 
+ 
+        # Subdir with VC exact version as name 
+        try: 
+            # Update the VC version with real one instead of VS version 
+            vc_ver = listdir(guess_vc)[-1] 
+            self.vc_ver = self._as_float_version(vc_ver) 
+            return join(guess_vc, vc_ver) 
+        except (OSError, IOError, IndexError): 
+            return '' 
+ 
+    def _guess_vc_legacy(self): 
+        """ 
+        Locate Visual C++ for versions prior to 2017. 
+ 
+        Return 
+        ------ 
+        str 
+            path 
+        """ 
+        default = join(self.ProgramFilesx86, 
+                       r'Microsoft Visual Studio %0.1f\VC' % self.vs_ver) 
+ 
+        # Try to get "VC++ for Python" path from registry as default path 
+        reg_path = join(self.ri.vc_for_python, '%0.1f' % self.vs_ver) 
+        python_vc = self.ri.lookup(reg_path, 'installdir') 
+        default_vc = join(python_vc, 'VC') if python_vc else default 
+ 
+        # Try to get path from registry, if fail use default path 
+        return self.ri.lookup(self.ri.vc, '%0.1f' % self.vs_ver) or default_vc 
+ 
     @property
     def WindowsSdkVersion(self):
         """
-        Microsoft Windows SDK versions for specified MSVC++ version.
-
-        Return
-        ------
-        tuple of str
-            versions
-        """
-        if self.vs_ver <= 9.0:
-            return '7.0', '6.1', '6.0a'
-        elif self.vs_ver == 10.0:
-            return '7.1', '7.0a'
-        elif self.vs_ver == 11.0:
-            return '8.0', '8.0a'
-        elif self.vs_ver == 12.0:
-            return '8.1', '8.1a'
-        elif self.vs_ver >= 14.0:
-            return '10.0', '8.1'
-
-    @property
-    def WindowsSdkLastVersion(self):
-        """
-        Microsoft Windows SDK last version.
-
-        Return
-        ------
-        str
-            version
-        """
-        return self._use_last_dir_name(join(self.WindowsSdkDir, 'lib'))
+        Microsoft Windows SDK versions for specified MSVC++ version. 
+ 
+        Return 
+        ------ 
+        tuple of str 
+            versions 
+        """
+        if self.vs_ver <= 9.0: 
+            return '7.0', '6.1', '6.0a' 
+        elif self.vs_ver == 10.0: 
+            return '7.1', '7.0a' 
+        elif self.vs_ver == 11.0: 
+            return '8.0', '8.0a' 
+        elif self.vs_ver == 12.0: 
+            return '8.1', '8.1a' 
+        elif self.vs_ver >= 14.0: 
+            return '10.0', '8.1' 
 
     @property
+    def WindowsSdkLastVersion(self): 
+        """ 
+        Microsoft Windows SDK last version. 
+ 
+        Return 
+        ------ 
+        str 
+            version 
+        """ 
+        return self._use_last_dir_name(join(self.WindowsSdkDir, 'lib')) 
+ 
+    @property 
     def WindowsSdkDir(self):
         """
         Microsoft Windows SDK directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
         sdkdir = ''
         for ver in self.WindowsSdkVersion:
             # Try to get it from registry
-            loc = join(self.ri.windows_sdk, 'v%s' % ver)
+            loc = join(self.ri.windows_sdk, 'v%s' % ver) 
             sdkdir = self.ri.lookup(loc, 'installationfolder')
             if sdkdir:
                 break
-        if not sdkdir or not isdir(sdkdir):
+        if not sdkdir or not isdir(sdkdir): 
             # Try to get "VC++ for Python" version from registry
-            path = join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
+            path = join(self.ri.vc_for_python, '%0.1f' % self.vc_ver) 
             install_base = self.ri.lookup(path, 'installdir')
             if install_base:
-                sdkdir = join(install_base, 'WinSDK')
-        if not sdkdir or not isdir(sdkdir):
+                sdkdir = join(install_base, 'WinSDK') 
+        if not sdkdir or not isdir(sdkdir): 
             # If fail, use default new path
             for ver in self.WindowsSdkVersion:
                 intver = ver[:ver.rfind('.')]
-                path = r'Microsoft SDKs\Windows Kits\%s' % intver
-                d = join(self.ProgramFiles, path)
-                if isdir(d):
+                path = r'Microsoft SDKs\Windows Kits\%s' % intver 
+                d = join(self.ProgramFiles, path) 
+                if isdir(d): 
                     sdkdir = d
-        if not sdkdir or not isdir(sdkdir):
+        if not sdkdir or not isdir(sdkdir): 
             # If fail, use default old path
             for ver in self.WindowsSdkVersion:
                 path = r'Microsoft SDKs\Windows\v%s' % ver
-                d = join(self.ProgramFiles, path)
-                if isdir(d):
+                d = join(self.ProgramFiles, path) 
+                if isdir(d): 
                     sdkdir = d
         if not sdkdir:
             # If fail, use Platform SDK
-            sdkdir = join(self.VCInstallDir, 'PlatformSDK')
+            sdkdir = join(self.VCInstallDir, 'PlatformSDK') 
         return sdkdir
 
     @property
     def WindowsSDKExecutablePath(self):
         """
         Microsoft Windows SDK executable directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
         # Find WinSDK NetFx Tools registry dir name
-        if self.vs_ver <= 11.0:
+        if self.vs_ver <= 11.0: 
             netfxver = 35
             arch = ''
         else:
             netfxver = 40
-            hidex86 = True if self.vs_ver <= 12.0 else False
+            hidex86 = True if self.vs_ver <= 12.0 else False 
             arch = self.pi.current_dir(x64=True, hidex86=hidex86)
         fx = 'WinSDK-NetFx%dTools%s' % (netfxver, arch.replace('\\', '-'))
 
-        # list all possibles registry paths
+        # list all possibles registry paths 
         regpaths = []
-        if self.vs_ver >= 14.0:
+        if self.vs_ver >= 14.0: 
             for ver in self.NetFxSdkVersion:
-                regpaths += [join(self.ri.netfx_sdk, ver, fx)]
+                regpaths += [join(self.ri.netfx_sdk, ver, fx)] 
 
         for ver in self.WindowsSdkVersion:
-            regpaths += [join(self.ri.windows_sdk, 'v%sA' % ver, fx)]
+            regpaths += [join(self.ri.windows_sdk, 'v%sA' % ver, fx)] 
 
         # Return installation folder from the more recent path
         for path in regpaths:
             execpath = self.ri.lookup(path, 'installationfolder')
             if execpath:
-                return execpath
+                return execpath 
 
     @property
     def FSharpInstallDir(self):
         """
         Microsoft Visual F# directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
-        path = join(self.ri.visualstudio, r'%0.1f\Setup\F#' % self.vs_ver)
+        path = join(self.ri.visualstudio, r'%0.1f\Setup\F#' % self.vs_ver) 
         return self.ri.lookup(path, 'productdir') or ''
 
     @property
     def UniversalCRTSdkDir(self):
         """
         Microsoft Universal CRT SDK directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
         # Set Kit Roots versions for specified MSVC++ version
-        vers = ('10', '81') if self.vs_ver >= 14.0 else ()
+        vers = ('10', '81') if self.vs_ver >= 14.0 else () 
 
         # Find path of the more recent Kit
         for ver in vers:
             sdkdir = self.ri.lookup(self.ri.windows_kits_roots,
                                     'kitsroot%s' % ver)
             if sdkdir:
-                return sdkdir or ''
-
-    @property
-    def UniversalCRTSdkLastVersion(self):
-        """
-        Microsoft Universal C Runtime SDK last version.
-
-        Return
-        ------
-        str
-            version
-        """
-        return self._use_last_dir_name(join(self.UniversalCRTSdkDir, 'lib'))
+                return sdkdir or '' 
 
     @property
+    def UniversalCRTSdkLastVersion(self): 
+        """ 
+        Microsoft Universal C Runtime SDK last version. 
+ 
+        Return 
+        ------ 
+        str 
+            version 
+        """ 
+        return self._use_last_dir_name(join(self.UniversalCRTSdkDir, 'lib')) 
+ 
+    @property 
     def NetFxSdkVersion(self):
         """
         Microsoft .NET Framework SDK versions.
-
-        Return
-        ------
-        tuple of str
-            versions
-        """
-        # Set FxSdk versions for specified VS version
-        return (('4.7.2', '4.7.1', '4.7',
-                 '4.6.2', '4.6.1', '4.6',
-                 '4.5.2', '4.5.1', '4.5')
-                if self.vs_ver >= 14.0 else ())
+ 
+        Return 
+        ------ 
+        tuple of str 
+            versions 
+        """
+        # Set FxSdk versions for specified VS version 
+        return (('4.7.2', '4.7.1', '4.7', 
+                 '4.6.2', '4.6.1', '4.6', 
+                 '4.5.2', '4.5.1', '4.5') 
+                if self.vs_ver >= 14.0 else ()) 
 
     @property
     def NetFxSdkDir(self):
         """
         Microsoft .NET Framework SDK directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
-        sdkdir = ''
+        sdkdir = '' 
         for ver in self.NetFxSdkVersion:
-            loc = join(self.ri.netfx_sdk, ver)
+            loc = join(self.ri.netfx_sdk, ver) 
             sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder')
             if sdkdir:
                 break
-        return sdkdir
+        return sdkdir 
 
     @property
     def FrameworkDir32(self):
         """
         Microsoft .NET Framework 32bit directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
         # Default path
-        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework')
+        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework') 
 
         # Try to get path from registry, if fail use default path
         return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw
@@ -954,14 +954,14 @@ class SystemInfo:
     def FrameworkDir64(self):
         """
         Microsoft .NET Framework 64bit directory.
-
-        Return
-        ------
-        str
-            path
+ 
+        Return 
+        ------ 
+        str 
+            path 
         """
         # Default path
-        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework64')
+        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework64') 
 
         # Try to get path from registry, if fail use default path
         return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw
@@ -970,11 +970,11 @@ class SystemInfo:
     def FrameworkVersion32(self):
         """
         Microsoft .NET Framework 32bit versions.
-
-        Return
-        ------
-        tuple of str
-            versions
+ 
+        Return 
+        ------ 
+        tuple of str 
+            versions 
         """
         return self._find_dot_net_versions(32)
 
@@ -982,15 +982,15 @@ class SystemInfo:
     def FrameworkVersion64(self):
         """
         Microsoft .NET Framework 64bit versions.
-
-        Return
-        ------
-        tuple of str
-            versions
+ 
+        Return 
+        ------ 
+        tuple of str 
+            versions 
         """
         return self._find_dot_net_versions(64)
 
-    def _find_dot_net_versions(self, bits):
+    def _find_dot_net_versions(self, bits): 
         """
         Find Microsoft .NET Framework versions.
 
@@ -998,59 +998,59 @@ class SystemInfo:
         ----------
         bits: int
             Platform number of bits: 32 or 64.
-
-        Return
-        ------
-        tuple of str
-            versions
+ 
+        Return 
+        ------ 
+        tuple of str 
+            versions 
         """
-        # Find actual .NET version in registry
-        reg_ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits)
-        dot_net_dir = getattr(self, 'FrameworkDir%d' % bits)
-        ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or ''
+        # Find actual .NET version in registry 
+        reg_ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits) 
+        dot_net_dir = getattr(self, 'FrameworkDir%d' % bits) 
+        ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or '' 
 
         # Set .NET versions for specified MSVC++ version
-        if self.vs_ver >= 12.0:
-            return ver, 'v4.0'
-        elif self.vs_ver >= 10.0:
-            return 'v4.0.30319' if ver.lower()[:2] != 'v4' else ver, 'v3.5'
-        elif self.vs_ver == 9.0:
-            return 'v3.5', 'v2.0.50727'
-        elif self.vs_ver == 8.0:
-            return 'v3.0', 'v2.0.50727'
-
-    @staticmethod
-    def _use_last_dir_name(path, prefix=''):
-        """
-        Return name of the last dir in path or '' if no dir found.
-
-        Parameters
-        ----------
-        path: str
-            Use dirs in this path
-        prefix: str
-            Use only dirs starting by this prefix
-
-        Return
-        ------
-        str
-            name
-        """
-        matching_dirs = (
-            dir_name
-            for dir_name in reversed(listdir(path))
-            if isdir(join(path, dir_name)) and
-            dir_name.startswith(prefix)
-        )
-        return next(matching_dirs, None) or ''
-
-
+        if self.vs_ver >= 12.0: 
+            return ver, 'v4.0' 
+        elif self.vs_ver >= 10.0: 
+            return 'v4.0.30319' if ver.lower()[:2] != 'v4' else ver, 'v3.5' 
+        elif self.vs_ver == 9.0: 
+            return 'v3.5', 'v2.0.50727' 
+        elif self.vs_ver == 8.0: 
+            return 'v3.0', 'v2.0.50727' 
+
+    @staticmethod 
+    def _use_last_dir_name(path, prefix=''): 
+        """ 
+        Return name of the last dir in path or '' if no dir found. 
+
+        Parameters 
+        ---------- 
+        path: str 
+            Use dirs in this path 
+        prefix: str 
+            Use only dirs starting by this prefix 
+ 
+        Return 
+        ------ 
+        str 
+            name 
+        """ 
+        matching_dirs = ( 
+            dir_name 
+            for dir_name in reversed(listdir(path)) 
+            if isdir(join(path, dir_name)) and 
+            dir_name.startswith(prefix) 
+        ) 
+        return next(matching_dirs, None) or '' 
+ 
+ 
 class EnvironmentInfo:
     """
     Return environment variables for specified Microsoft Visual C++ version
     and platform : Lib, Include, Path and libpath.
 
-    This function is compatible with Microsoft Visual C++ 9.0 to 14.X.
+    This function is compatible with Microsoft Visual C++ 9.0 to 14.X. 
 
     Script created by analysing Microsoft environment configuration files like
     "vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...
@@ -1067,312 +1067,312 @@ class EnvironmentInfo:
     """
 
     # Variables and properties in this class use originals CamelCase variables
-    # names from Microsoft source files for more easy comparison.
+    # names from Microsoft source files for more easy comparison. 
 
-    def __init__(self, arch, vc_ver=None, vc_min_ver=0):
+    def __init__(self, arch, vc_ver=None, vc_min_ver=0): 
         self.pi = PlatformInfo(arch)
         self.ri = RegistryInfo(self.pi)
         self.si = SystemInfo(self.ri, vc_ver)
 
-        if self.vc_ver < vc_min_ver:
-            err = 'No suitable Microsoft Visual C++ version found'
-            raise distutils.errors.DistutilsPlatformError(err)
-
-    @property
-    def vs_ver(self):
-        """
-        Microsoft Visual Studio.
-
-        Return
-        ------
-        float
-            version
-        """
-        return self.si.vs_ver
+        if self.vc_ver < vc_min_ver: 
+            err = 'No suitable Microsoft Visual C++ version found' 
+            raise distutils.errors.DistutilsPlatformError(err) 
 
     @property
+    def vs_ver(self): 
+        """ 
+        Microsoft Visual Studio. 
+ 
+        Return 
+        ------ 
+        float 
+            version 
+        """ 
+        return self.si.vs_ver 
+ 
+    @property 
     def vc_ver(self):
         """
         Microsoft Visual C++ version.
-
-        Return
-        ------
-        float
-            version
+ 
+        Return 
+        ------ 
+        float 
+            version 
         """
         return self.si.vc_ver
 
     @property
     def VSTools(self):
         """
-        Microsoft Visual Studio Tools.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Visual Studio Tools. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
         paths = [r'Common7\IDE', r'Common7\Tools']
 
-        if self.vs_ver >= 14.0:
+        if self.vs_ver >= 14.0: 
             arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
             paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow']
             paths += [r'Team Tools\Performance Tools']
             paths += [r'Team Tools\Performance Tools%s' % arch_subdir]
 
-        return [join(self.si.VSInstallDir, path) for path in paths]
+        return [join(self.si.VSInstallDir, path) for path in paths] 
 
     @property
     def VCIncludes(self):
         """
-        Microsoft Visual C++ & Microsoft Foundation Class Includes.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Visual C++ & Microsoft Foundation Class Includes. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        return [join(self.si.VCInstallDir, 'Include'),
-                join(self.si.VCInstallDir, r'ATLMFC\Include')]
+        return [join(self.si.VCInstallDir, 'Include'), 
+                join(self.si.VCInstallDir, r'ATLMFC\Include')] 
 
     @property
     def VCLibraries(self):
         """
-        Microsoft Visual C++ & Microsoft Foundation Class Libraries.
-
-        Return
-        ------
-        list of str
-            paths
-        """
-        if self.vs_ver >= 15.0:
-            arch_subdir = self.pi.target_dir(x64=True)
-        else:
-            arch_subdir = self.pi.target_dir(hidex86=True)
+        Microsoft Visual C++ & Microsoft Foundation Class Libraries. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
+        """
+        if self.vs_ver >= 15.0: 
+            arch_subdir = self.pi.target_dir(x64=True) 
+        else: 
+            arch_subdir = self.pi.target_dir(hidex86=True) 
         paths = ['Lib%s' % arch_subdir, r'ATLMFC\Lib%s' % arch_subdir]
 
-        if self.vs_ver >= 14.0:
+        if self.vs_ver >= 14.0: 
             paths += [r'Lib\store%s' % arch_subdir]
 
-        return [join(self.si.VCInstallDir, path) for path in paths]
+        return [join(self.si.VCInstallDir, path) for path in paths] 
 
     @property
     def VCStoreRefs(self):
         """
-        Microsoft Visual C++ store references Libraries.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Visual C++ store references Libraries. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver < 14.0:
+        if self.vs_ver < 14.0: 
             return []
-        return [join(self.si.VCInstallDir, r'Lib\store\references')]
+        return [join(self.si.VCInstallDir, r'Lib\store\references')] 
 
     @property
     def VCTools(self):
         """
-        Microsoft Visual C++ Tools.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Visual C++ Tools. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
         si = self.si
-        tools = [join(si.VCInstallDir, 'VCPackages')]
+        tools = [join(si.VCInstallDir, 'VCPackages')] 
 
-        forcex86 = True if self.vs_ver <= 10.0 else False
+        forcex86 = True if self.vs_ver <= 10.0 else False 
         arch_subdir = self.pi.cross_dir(forcex86)
         if arch_subdir:
-            tools += [join(si.VCInstallDir, 'Bin%s' % arch_subdir)]
+            tools += [join(si.VCInstallDir, 'Bin%s' % arch_subdir)] 
 
-        if self.vs_ver == 14.0:
+        if self.vs_ver == 14.0: 
             path = 'Bin%s' % self.pi.current_dir(hidex86=True)
-            tools += [join(si.VCInstallDir, path)]
-
-        elif self.vs_ver >= 15.0:
-            host_dir = (r'bin\HostX86%s' if self.pi.current_is_x86() else
-                        r'bin\HostX64%s')
-            tools += [join(
-                si.VCInstallDir, host_dir % self.pi.target_dir(x64=True))]
-
-            if self.pi.current_cpu != self.pi.target_cpu:
-                tools += [join(
-                    si.VCInstallDir, host_dir % self.pi.current_dir(x64=True))]
-
+            tools += [join(si.VCInstallDir, path)] 
+
+        elif self.vs_ver >= 15.0: 
+            host_dir = (r'bin\HostX86%s' if self.pi.current_is_x86() else 
+                        r'bin\HostX64%s') 
+            tools += [join( 
+                si.VCInstallDir, host_dir % self.pi.target_dir(x64=True))] 
+ 
+            if self.pi.current_cpu != self.pi.target_cpu: 
+                tools += [join( 
+                    si.VCInstallDir, host_dir % self.pi.current_dir(x64=True))] 
+ 
         else:
-            tools += [join(si.VCInstallDir, 'Bin')]
+            tools += [join(si.VCInstallDir, 'Bin')] 
 
         return tools
 
     @property
     def OSLibraries(self):
         """
-        Microsoft Windows SDK Libraries.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Windows SDK Libraries. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver <= 10.0:
+        if self.vs_ver <= 10.0: 
             arch_subdir = self.pi.target_dir(hidex86=True, x64=True)
-            return [join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)]
+            return [join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)] 
 
         else:
             arch_subdir = self.pi.target_dir(x64=True)
-            lib = join(self.si.WindowsSdkDir, 'lib')
-            libver = self._sdk_subdir
-            return [join(lib, '%sum%s' % (libver , arch_subdir))]
+            lib = join(self.si.WindowsSdkDir, 'lib') 
+            libver = self._sdk_subdir 
+            return [join(lib, '%sum%s' % (libver , arch_subdir))] 
 
     @property
     def OSIncludes(self):
         """
-        Microsoft Windows SDK Include.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Windows SDK Include. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        include = join(self.si.WindowsSdkDir, 'include')
+        include = join(self.si.WindowsSdkDir, 'include') 
 
-        if self.vs_ver <= 10.0:
-            return [include, join(include, 'gl')]
+        if self.vs_ver <= 10.0: 
+            return [include, join(include, 'gl')] 
 
         else:
-            if self.vs_ver >= 14.0:
-                sdkver = self._sdk_subdir
+            if self.vs_ver >= 14.0: 
+                sdkver = self._sdk_subdir 
             else:
                 sdkver = ''
-            return [join(include, '%sshared' % sdkver),
-                    join(include, '%sum' % sdkver),
-                    join(include, '%swinrt' % sdkver)]
+            return [join(include, '%sshared' % sdkver), 
+                    join(include, '%sum' % sdkver), 
+                    join(include, '%swinrt' % sdkver)] 
 
     @property
     def OSLibpath(self):
         """
-        Microsoft Windows SDK Libraries Paths.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Windows SDK Libraries Paths. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        ref = join(self.si.WindowsSdkDir, 'References')
+        ref = join(self.si.WindowsSdkDir, 'References') 
         libpath = []
 
-        if self.vs_ver <= 9.0:
+        if self.vs_ver <= 9.0: 
             libpath += self.OSLibraries
 
-        if self.vs_ver >= 11.0:
-            libpath += [join(ref, r'CommonConfiguration\Neutral')]
+        if self.vs_ver >= 11.0: 
+            libpath += [join(ref, r'CommonConfiguration\Neutral')] 
 
-        if self.vs_ver >= 14.0:
+        if self.vs_ver >= 14.0: 
             libpath += [
                 ref,
-                join(self.si.WindowsSdkDir, 'UnionMetadata'),
-                join(ref, 'Windows.Foundation.UniversalApiContract', '1.0.0.0'),
-                join(ref, 'Windows.Foundation.FoundationContract', '1.0.0.0'),
-                join(ref,'Windows.Networking.Connectivity.WwanContract',
-                     '1.0.0.0'),
-                join(self.si.WindowsSdkDir, 'ExtensionSDKs', 'Microsoft.VCLibs',
-                     '%0.1f' % self.vs_ver, 'References', 'CommonConfiguration',
-                     'neutral'),
+                join(self.si.WindowsSdkDir, 'UnionMetadata'), 
+                join(ref, 'Windows.Foundation.UniversalApiContract', '1.0.0.0'), 
+                join(ref, 'Windows.Foundation.FoundationContract', '1.0.0.0'), 
+                join(ref,'Windows.Networking.Connectivity.WwanContract', 
+                     '1.0.0.0'), 
+                join(self.si.WindowsSdkDir, 'ExtensionSDKs', 'Microsoft.VCLibs', 
+                     '%0.1f' % self.vs_ver, 'References', 'CommonConfiguration', 
+                     'neutral'), 
             ]
         return libpath
 
     @property
     def SdkTools(self):
         """
-        Microsoft Windows SDK Tools.
-
-        Return
-        ------
-        list of str
-            paths
-        """
-        return list(self._sdk_tools())
-
-    def _sdk_tools(self):
-        """
-        Microsoft Windows SDK Tools paths generator.
-
-        Return
-        ------
-        generator of str
-            paths
-        """
-        if self.vs_ver < 15.0:
-            bin_dir = 'Bin' if self.vs_ver <= 11.0 else r'Bin\x86'
-            yield join(self.si.WindowsSdkDir, bin_dir)
-
+        Microsoft Windows SDK Tools. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
+        """
+        return list(self._sdk_tools()) 
+
+    def _sdk_tools(self): 
+        """ 
+        Microsoft Windows SDK Tools paths generator. 
+ 
+        Return 
+        ------ 
+        generator of str 
+            paths 
+        """ 
+        if self.vs_ver < 15.0: 
+            bin_dir = 'Bin' if self.vs_ver <= 11.0 else r'Bin\x86' 
+            yield join(self.si.WindowsSdkDir, bin_dir) 
+ 
         if not self.pi.current_is_x86():
             arch_subdir = self.pi.current_dir(x64=True)
             path = 'Bin%s' % arch_subdir
-            yield join(self.si.WindowsSdkDir, path)
+            yield join(self.si.WindowsSdkDir, path) 
 
-        if self.vs_ver in (10.0, 11.0):
+        if self.vs_ver in (10.0, 11.0): 
             if self.pi.target_is_x86():
                 arch_subdir = ''
             else:
                 arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
             path = r'Bin\NETFX 4.0 Tools%s' % arch_subdir
-            yield join(self.si.WindowsSdkDir, path)
-
-        elif self.vs_ver >= 15.0:
-            path = join(self.si.WindowsSdkDir, 'Bin')
-            arch_subdir = self.pi.current_dir(x64=True)
-            sdkver = self.si.WindowsSdkLastVersion
-            yield join(path, '%s%s' % (sdkver, arch_subdir))
-
+            yield join(self.si.WindowsSdkDir, path) 
+
+        elif self.vs_ver >= 15.0: 
+            path = join(self.si.WindowsSdkDir, 'Bin') 
+            arch_subdir = self.pi.current_dir(x64=True) 
+            sdkver = self.si.WindowsSdkLastVersion 
+            yield join(path, '%s%s' % (sdkver, arch_subdir)) 
+ 
         if self.si.WindowsSDKExecutablePath:
-            yield self.si.WindowsSDKExecutablePath
-
-    @property
-    def _sdk_subdir(self):
-        """
-        Microsoft Windows SDK version subdir.
-
-        Return
-        ------
-        str
-            subdir
-        """
-        ucrtver = self.si.WindowsSdkLastVersion
-        return ('%s\\' % ucrtver) if ucrtver else ''
+            yield self.si.WindowsSDKExecutablePath 
+
+    @property 
+    def _sdk_subdir(self): 
+        """ 
+        Microsoft Windows SDK version subdir. 
+ 
+        Return 
+        ------ 
+        str 
+            subdir 
+        """ 
+        ucrtver = self.si.WindowsSdkLastVersion 
+        return ('%s\\' % ucrtver) if ucrtver else '' 
 
     @property
     def SdkSetup(self):
         """
-        Microsoft Windows SDK Setup.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Windows SDK Setup. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver > 9.0:
+        if self.vs_ver > 9.0: 
             return []
 
-        return [join(self.si.WindowsSdkDir, 'Setup')]
+        return [join(self.si.WindowsSdkDir, 'Setup')] 
 
     @property
     def FxTools(self):
         """
-        Microsoft .NET Framework Tools.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft .NET Framework Tools. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
         pi = self.pi
         si = self.si
 
-        if self.vs_ver <= 10.0:
+        if self.vs_ver <= 10.0: 
             include32 = True
             include64 = not pi.target_is_x86() and not pi.current_is_x86()
         else:
@@ -1381,196 +1381,196 @@ class EnvironmentInfo:
 
         tools = []
         if include32:
-            tools += [join(si.FrameworkDir32, ver)
+            tools += [join(si.FrameworkDir32, ver) 
                       for ver in si.FrameworkVersion32]
         if include64:
-            tools += [join(si.FrameworkDir64, ver)
+            tools += [join(si.FrameworkDir64, ver) 
                       for ver in si.FrameworkVersion64]
         return tools
 
     @property
     def NetFxSDKLibraries(self):
         """
-        Microsoft .Net Framework SDK Libraries.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft .Net Framework SDK Libraries. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
+        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir: 
             return []
 
         arch_subdir = self.pi.target_dir(x64=True)
-        return [join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)]
+        return [join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)] 
 
     @property
     def NetFxSDKIncludes(self):
         """
-        Microsoft .Net Framework SDK Includes.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft .Net Framework SDK Includes. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
+        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir: 
             return []
 
-        return [join(self.si.NetFxSdkDir, r'include\um')]
+        return [join(self.si.NetFxSdkDir, r'include\um')] 
 
     @property
     def VsTDb(self):
         """
-        Microsoft Visual Studio Team System Database.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Visual Studio Team System Database. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        return [join(self.si.VSInstallDir, r'VSTSDB\Deploy')]
+        return [join(self.si.VSInstallDir, r'VSTSDB\Deploy')] 
 
     @property
     def MSBuild(self):
         """
-        Microsoft Build Engine.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Build Engine. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver < 12.0:
+        if self.vs_ver < 12.0: 
             return []
-        elif self.vs_ver < 15.0:
-            base_path = self.si.ProgramFilesx86
-            arch_subdir = self.pi.current_dir(hidex86=True)
-        else:
-            base_path = self.si.VSInstallDir
-            arch_subdir = ''
-
-        path = r'MSBuild\%0.1f\bin%s' % (self.vs_ver, arch_subdir)
-        build = [join(base_path, path)]
-
-        if self.vs_ver >= 15.0:
-            # Add Roslyn C# & Visual Basic Compiler
-            build += [join(base_path, path, 'Roslyn')]
-
-        return build
-
+        elif self.vs_ver < 15.0: 
+            base_path = self.si.ProgramFilesx86 
+            arch_subdir = self.pi.current_dir(hidex86=True) 
+        else: 
+            base_path = self.si.VSInstallDir 
+            arch_subdir = '' 
+
+        path = r'MSBuild\%0.1f\bin%s' % (self.vs_ver, arch_subdir) 
+        build = [join(base_path, path)] 
+
+        if self.vs_ver >= 15.0: 
+            # Add Roslyn C# & Visual Basic Compiler 
+            build += [join(base_path, path, 'Roslyn')] 
+ 
+        return build 
+ 
     @property
     def HTMLHelpWorkshop(self):
         """
-        Microsoft HTML Help Workshop.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft HTML Help Workshop. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver < 11.0:
+        if self.vs_ver < 11.0: 
             return []
 
-        return [join(self.si.ProgramFilesx86, 'HTML Help Workshop')]
+        return [join(self.si.ProgramFilesx86, 'HTML Help Workshop')] 
 
     @property
     def UCRTLibraries(self):
         """
-        Microsoft Universal C Runtime SDK Libraries.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Universal C Runtime SDK Libraries. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver < 14.0:
+        if self.vs_ver < 14.0: 
             return []
 
         arch_subdir = self.pi.target_dir(x64=True)
-        lib = join(self.si.UniversalCRTSdkDir, 'lib')
-        ucrtver = self._ucrt_subdir
-        return [join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]
+        lib = join(self.si.UniversalCRTSdkDir, 'lib') 
+        ucrtver = self._ucrt_subdir 
+        return [join(lib, '%sucrt%s' % (ucrtver, arch_subdir))] 
 
     @property
     def UCRTIncludes(self):
         """
-        Microsoft Universal C Runtime SDK Include.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Universal C Runtime SDK Include. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if self.vs_ver < 14.0:
+        if self.vs_ver < 14.0: 
             return []
 
-        include = join(self.si.UniversalCRTSdkDir, 'include')
-        return [join(include, '%sucrt' % self._ucrt_subdir)]
-
-    @property
-    def _ucrt_subdir(self):
-        """
-        Microsoft Universal C Runtime SDK version subdir.
-
-        Return
-        ------
-        str
-            subdir
-        """
-        ucrtver = self.si.UniversalCRTSdkLastVersion
-        return ('%s\\' % ucrtver) if ucrtver else ''
+        include = join(self.si.UniversalCRTSdkDir, 'include') 
+        return [join(include, '%sucrt' % self._ucrt_subdir)] 
 
     @property
+    def _ucrt_subdir(self): 
+        """ 
+        Microsoft Universal C Runtime SDK version subdir. 
+ 
+        Return 
+        ------ 
+        str 
+            subdir 
+        """ 
+        ucrtver = self.si.UniversalCRTSdkLastVersion 
+        return ('%s\\' % ucrtver) if ucrtver else '' 
+ 
+    @property 
     def FSharp(self):
         """
-        Microsoft Visual F#.
-
-        Return
-        ------
-        list of str
-            paths
+        Microsoft Visual F#. 
+ 
+        Return 
+        ------ 
+        list of str 
+            paths 
         """
-        if 11.0 > self.vs_ver > 12.0:
+        if 11.0 > self.vs_ver > 12.0: 
             return []
 
-        return [self.si.FSharpInstallDir]
+        return [self.si.FSharpInstallDir] 
 
     @property
     def VCRuntimeRedist(self):
         """
-        Microsoft Visual C++ runtime redistributable dll.
-
-        Return
-        ------
-        str
-            path
-        """
-        vcruntime = 'vcruntime%d0.dll' % self.vc_ver
-        arch_subdir = self.pi.target_dir(x64=True).strip('\\')
-
-        # Installation prefixes candidates
-        prefixes = []
-        tools_path = self.si.VCInstallDir
-        redist_path = dirname(tools_path.replace(r'\Tools', r'\Redist'))
-        if isdir(redist_path):
-            # Redist version may not be exactly the same as tools
-            redist_path = join(redist_path, listdir(redist_path)[-1])
-            prefixes += [redist_path, join(redist_path, 'onecore')]
-
-        prefixes += [join(tools_path, 'redist')]  # VS14 legacy path
-
-        # CRT directory
-        crt_dirs = ('Microsoft.VC%d.CRT' % (self.vc_ver * 10),
-                    # Sometime store in directory with VS version instead of VC
-                    'Microsoft.VC%d.CRT' % (int(self.vs_ver) * 10))
-
-        # vcruntime path
-        for prefix, crt_dir in itertools.product(prefixes, crt_dirs):
-            path = join(prefix, arch_subdir, crt_dir, vcruntime)
-            if isfile(path):
-                return path
-
+        Microsoft Visual C++ runtime redistributable dll. 
+ 
+        Return 
+        ------ 
+        str 
+            path 
+        """
+        vcruntime = 'vcruntime%d0.dll' % self.vc_ver 
+        arch_subdir = self.pi.target_dir(x64=True).strip('\\') 
+
+        # Installation prefixes candidates 
+        prefixes = [] 
+        tools_path = self.si.VCInstallDir 
+        redist_path = dirname(tools_path.replace(r'\Tools', r'\Redist')) 
+        if isdir(redist_path): 
+            # Redist version may not be exactly the same as tools 
+            redist_path = join(redist_path, listdir(redist_path)[-1]) 
+            prefixes += [redist_path, join(redist_path, 'onecore')] 
+ 
+        prefixes += [join(tools_path, 'redist')]  # VS14 legacy path 
+ 
+        # CRT directory 
+        crt_dirs = ('Microsoft.VC%d.CRT' % (self.vc_ver * 10), 
+                    # Sometime store in directory with VS version instead of VC 
+                    'Microsoft.VC%d.CRT' % (int(self.vs_ver) * 10)) 
+ 
+        # vcruntime path 
+        for prefix, crt_dir in itertools.product(prefixes, crt_dirs): 
+            path = join(prefix, arch_subdir, crt_dir, vcruntime) 
+            if isfile(path): 
+                return path 
+ 
     def return_env(self, exists=True):
         """
         Return environment dict.
@@ -1579,11 +1579,11 @@ class EnvironmentInfo:
         ----------
         exists: bool
             It True, only return existing paths.
-
-        Return
-        ------
-        dict
-            environment
+ 
+        Return 
+        ------ 
+        dict 
+            environment 
         """
         env = dict(
             include=self._build_paths('include',
@@ -1617,7 +1617,7 @@ class EnvironmentInfo:
                                     self.FSharp],
                                    exists),
         )
-        if self.vs_ver >= 14 and isfile(self.VCRuntimeRedist):
+        if self.vs_ver >= 14 and isfile(self.VCRuntimeRedist): 
             env['py_vcruntime_redist'] = self.VCRuntimeRedist
         return env
 
@@ -1628,35 +1628,35 @@ class EnvironmentInfo:
         unique, extant, directories from those paths and from
         the environment variable. Raise an error if no paths
         are resolved.
-
-        Parameters
-        ----------
-        name: str
-            Environment variable name
-        spec_path_lists: list of str
-            Paths
-        exists: bool
-            It True, only return existing paths.
-
-        Return
-        ------
-        str
-            Pathsep-separated paths
+ 
+        Parameters 
+        ---------- 
+        name: str 
+            Environment variable name 
+        spec_path_lists: list of str 
+            Paths 
+        exists: bool 
+            It True, only return existing paths. 
+ 
+        Return 
+        ------ 
+        str 
+            Pathsep-separated paths 
         """
         # flatten spec_path_lists
         spec_paths = itertools.chain.from_iterable(spec_path_lists)
-        env_paths = environ.get(name, '').split(pathsep)
+        env_paths = environ.get(name, '').split(pathsep) 
         paths = itertools.chain(spec_paths, env_paths)
-        extant_paths = list(filter(isdir, paths)) if exists else paths
+        extant_paths = list(filter(isdir, paths)) if exists else paths 
         if not extant_paths:
             msg = "%s environment variable is empty" % name.upper()
             raise distutils.errors.DistutilsPlatformError(msg)
         unique_paths = self._unique_everseen(extant_paths)
-        return pathsep.join(unique_paths)
+        return pathsep.join(unique_paths) 
 
     # from Python docs
-    @staticmethod
-    def _unique_everseen(iterable, key=None):
+    @staticmethod 
+    def _unique_everseen(iterable, key=None): 
         """
         List unique elements, preserving order.
         Remember all elements ever seen.
diff --git a/contrib/python/setuptools/py2/setuptools/namespaces.py b/contrib/python/setuptools/py2/setuptools/namespaces.py
index dc16106d3d..687afc508b 100644
--- a/contrib/python/setuptools/py2/setuptools/namespaces.py
+++ b/contrib/python/setuptools/py2/setuptools/namespaces.py
@@ -2,7 +2,7 @@ import os
 from distutils import log
 import itertools
 
-from setuptools.extern.six.moves import map
+from setuptools.extern.six.moves import map 
 
 
 flatten = itertools.chain.from_iterable
diff --git a/contrib/python/setuptools/py2/setuptools/package_index.py b/contrib/python/setuptools/py2/setuptools/package_index.py
index f419d47167..a458e5d05c 100644
--- a/contrib/python/setuptools/py2/setuptools/package_index.py
+++ b/contrib/python/setuptools/py2/setuptools/package_index.py
@@ -7,33 +7,33 @@ import socket
 import base64
 import hashlib
 import itertools
-import warnings
+import warnings 
 from functools import wraps
 
-from setuptools.extern import six
-from setuptools.extern.six.moves import urllib, http_client, configparser, map
+from setuptools.extern import six 
+from setuptools.extern.six.moves import urllib, http_client, configparser, map 
 
 import setuptools
 from pkg_resources import (
     CHECKOUT_DIST, Distribution, BINARY_DIST, normalize_path, SOURCE_DIST,
     Environment, find_distributions, safe_name, safe_version,
-    to_filename, Requirement, DEVELOP_DIST, EGG_DIST,
+    to_filename, Requirement, DEVELOP_DIST, EGG_DIST, 
 )
 from setuptools import ssl_support
 from distutils import log
 from distutils.errors import DistutilsError
 from fnmatch import translate
 from setuptools.py27compat import get_all_headers
-from setuptools.py33compat import unescape
-from setuptools.wheel import Wheel
-
-__metaclass__ = type
+from setuptools.py33compat import unescape 
+from setuptools.wheel import Wheel 
 
+__metaclass__ = type 
+ 
 EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.+!]+)$')
-HREF = re.compile(r"""href\s*=\s*['"]?([^'"> ]+)""", re.I)
+HREF = re.compile(r"""href\s*=\s*['"]?([^'"> ]+)""", re.I) 
 PYPI_MD5 = re.compile(
-    r'<a href="([^"#]+)">([^<]+)</a>\n\s+\(<a (?:title="MD5 hash"\n\s+)'
-    r'href="[^?]+\?:action=show_md5&amp;digest=([0-9a-f]{32})">md5</a>\)'
+    r'<a href="([^"#]+)">([^<]+)</a>\n\s+\(<a (?:title="MD5 hash"\n\s+)' 
+    r'href="[^?]+\?:action=show_md5&amp;digest=([0-9a-f]{32})">md5</a>\)' 
 )
 URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):', re.I).match
 EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()
@@ -46,7 +46,7 @@ __all__ = [
 _SOCKET_TIMEOUT = 15
 
 _tmpl = "setuptools/{setuptools.__version__} Python-urllib/{py_major}"
-user_agent = _tmpl.format(py_major='{}.{}'.format(*sys.version_info), setuptools=setuptools)
+user_agent = _tmpl.format(py_major='{}.{}'.format(*sys.version_info), setuptools=setuptools) 
 
 
 def parse_requirement_arg(spec):
@@ -114,17 +114,17 @@ def distros_for_location(location, basename, metadata=None):
     if basename.endswith('.egg') and '-' in basename:
         # only one, unambiguous interpretation
         return [Distribution.from_location(location, basename, metadata)]
-    if basename.endswith('.whl') and '-' in basename:
-        wheel = Wheel(basename)
-        if not wheel.is_compatible():
-            return []
-        return [Distribution(
-            location=location,
-            project_name=wheel.project_name,
-            version=wheel.version,
-            # Increase priority over eggs.
-            precedence=EGG_DIST + 1,
-        )]
+    if basename.endswith('.whl') and '-' in basename: 
+        wheel = Wheel(basename) 
+        if not wheel.is_compatible(): 
+            return [] 
+        return [Distribution( 
+            location=location, 
+            project_name=wheel.project_name, 
+            version=wheel.version, 
+            # Increase priority over eggs. 
+            precedence=EGG_DIST + 1, 
+        )] 
     if basename.endswith('.exe'):
         win_base, py_ver, platform = parse_bdist_wininst(basename)
         if win_base is not None:
@@ -150,7 +150,7 @@ def distros_for_filename(filename, metadata=None):
 def interpret_distro_name(
         location, basename, metadata, py_version=None, precedence=SOURCE_DIST,
         platform=None
-):
+): 
     """Generate alternative interpretations of a source distro name
 
     Note: if `location` is a filesystem filename, you should call
@@ -237,7 +237,7 @@ def find_external_links(url, page):
                 yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
 
 
-class ContentChecker:
+class ContentChecker: 
     """
     A null content checker that defines the interface for checking content
     """
@@ -299,9 +299,9 @@ class PackageIndex(Environment):
     """A distribution index that scans web pages for download URLs"""
 
     def __init__(
-            self, index_url="https://pypi.org/simple/", hosts=('*',),
+            self, index_url="https://pypi.org/simple/", hosts=('*',), 
             ca_bundle=None, verify_ssl=True, *args, **kw
-    ):
+    ): 
         Environment.__init__(self, *args, **kw)
         self.index_url = index_url + "/" [:not index_url.endswith('/')]
         self.scanned_urls = {}
@@ -355,8 +355,8 @@ class PackageIndex(Environment):
 
         base = f.url  # handle redirects
         page = f.read()
-        if not isinstance(page, str):
-            # In Python 3 and got bytes but want str.
+        if not isinstance(page, str): 
+            # In Python 3 and got bytes but want str. 
             if isinstance(f, urllib.error.HTTPError):
                 # Errors have no charset, assume latin1:
                 charset = 'latin-1'
@@ -391,9 +391,9 @@ class PackageIndex(Environment):
         is_file = s and s.group(1).lower() == 'file'
         if is_file or self.allows(urllib.parse.urlparse(url)[1]):
             return True
-        msg = (
-            "\nNote: Bypassing %s (disallowed host; see "
-            "http://bit.ly/2hrImnY for details).\n")
+        msg = ( 
+            "\nNote: Bypassing %s (disallowed host; see " 
+            "http://bit.ly/2hrImnY for details).\n") 
         if fatal:
             raise DistutilsError(msg % url)
         else:
@@ -511,16 +511,16 @@ class PackageIndex(Environment):
         """
         checker is a ContentChecker
         """
-        checker.report(
-            self.debug,
+        checker.report( 
+            self.debug, 
             "Validating %%s checksum for %s" % filename)
         if not checker.is_valid():
             tfp.close()
             os.unlink(filename)
             raise DistutilsError(
                 "%s validation failed for %s; "
-                "possible download problem?"
-                % (checker.hash.name, os.path.basename(filename))
+                "possible download problem?" 
+                % (checker.hash.name, os.path.basename(filename)) 
             )
 
     def add_find_links(self, urls):
@@ -548,8 +548,8 @@ class PackageIndex(Environment):
         if self[requirement.key]:  # we've seen at least one distro
             meth, msg = self.info, "Couldn't retrieve index page for %r"
         else:  # no distros seen for this name, might be misspelled
-            meth, msg = (
-                self.warn,
+            meth, msg = ( 
+                self.warn, 
                 "Couldn't find index page for %r (maybe misspelled?)")
         meth(msg, requirement.unsafe_name)
         self.scan_all()
@@ -590,7 +590,7 @@ class PackageIndex(Environment):
 
     def fetch_distribution(
             self, requirement, tmpdir, force_scan=False, source=False,
-            develop_ok=False, local_index=None):
+            develop_ok=False, local_index=None): 
         """Obtain a distribution suitable for fulfilling `requirement`
 
         `requirement` must be a ``pkg_resources.Requirement`` instance.
@@ -621,19 +621,19 @@ class PackageIndex(Environment):
 
                 if dist.precedence == DEVELOP_DIST and not develop_ok:
                     if dist not in skipped:
-                        self.warn(
-                            "Skipping development or system egg: %s", dist,
-                        )
+                        self.warn( 
+                            "Skipping development or system egg: %s", dist, 
+                        ) 
                         skipped[dist] = 1
                     continue
 
-                test = (
-                    dist in req
-                    and (dist.precedence <= SOURCE_DIST or not source)
-                )
-                if test:
-                    loc = self.download(dist.location, tmpdir)
-                    dist.download_location = loc
+                test = ( 
+                    dist in req 
+                    and (dist.precedence <= SOURCE_DIST or not source) 
+                ) 
+                if test: 
+                    loc = self.download(dist.location, tmpdir) 
+                    dist.download_location = loc 
                     if os.path.exists(dist.download_location):
                         return dist
 
@@ -723,10 +723,10 @@ class PackageIndex(Environment):
     def _download_to(self, url, filename):
         self.info("Downloading %s", url)
         # Download the file
-        fp = None
+        fp = None 
         try:
             checker = HashChecker.from_url(url)
-            fp = self.open_url(url)
+            fp = self.open_url(url) 
             if isinstance(fp, urllib.error.HTTPError):
                 raise DistutilsError(
                     "Can't download %s: %s %s" % (url, fp.code, fp.msg)
@@ -849,14 +849,14 @@ class PackageIndex(Environment):
         raise DistutilsError("Unexpected HTML page found at " + url)
 
     def _download_svn(self, url, filename):
-        warnings.warn("SVN download support is deprecated", UserWarning)
+        warnings.warn("SVN download support is deprecated", UserWarning) 
         url = url.split('#', 1)[0]  # remove any fragment for svn's sake
         creds = ''
         if url.lower().startswith('svn:') and '@' in url:
             scheme, netloc, path, p, q, f = urllib.parse.urlparse(url)
             if not netloc and path.startswith('//') and '/' in path[2:]:
                 netloc, path = path[2:].split('/', 1)
-                auth, host = _splituser(netloc)
+                auth, host = _splituser(netloc) 
                 if auth:
                     if ':' in auth:
                         user, pw = auth.split(':', 1)
@@ -897,7 +897,7 @@ class PackageIndex(Environment):
 
         if rev is not None:
             self.info("Checking out %s", rev)
-            os.system("git -C %s checkout --quiet %s" % (
+            os.system("git -C %s checkout --quiet %s" % ( 
                 filename,
                 rev,
             ))
@@ -913,7 +913,7 @@ class PackageIndex(Environment):
 
         if rev is not None:
             self.info("Updating to %s", rev)
-            os.system("hg --cwd %s up -C -r %s -q" % (
+            os.system("hg --cwd %s up -C -r %s -q" % ( 
                 filename,
                 rev,
             ))
@@ -936,19 +936,19 @@ entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub
 
 
 def decode_entity(match):
-    what = match.group(0)
-    return unescape(what)
+    what = match.group(0) 
+    return unescape(what) 
 
 
 def htmldecode(text):
-    """
-    Decode HTML entities in the given text.
-
-    >>> htmldecode(
-    ...     'https://../package_name-0.1.2.tar.gz'
-    ...     '?tokena=A&amp;tokenb=B">package_name-0.1.2.tar.gz')
-    'https://../package_name-0.1.2.tar.gz?tokena=A&tokenb=B">package_name-0.1.2.tar.gz'
-    """
+    """ 
+    Decode HTML entities in the given text. 
+ 
+    >>> htmldecode( 
+    ...     'https://../package_name-0.1.2.tar.gz' 
+    ...     '?tokena=A&amp;tokenb=B">package_name-0.1.2.tar.gz') 
+    'https://../package_name-0.1.2.tar.gz?tokena=A&tokenb=B">package_name-0.1.2.tar.gz' 
+    """ 
     return entity_sub(decode_entity, text)
 
 
@@ -982,14 +982,14 @@ def _encode_auth(auth):
     auth_s = urllib.parse.unquote(auth)
     # convert to bytes
     auth_bytes = auth_s.encode()
-    encoded_bytes = base64.b64encode(auth_bytes)
+    encoded_bytes = base64.b64encode(auth_bytes) 
     # convert back to a string
     encoded = encoded_bytes.decode()
     # strip the trailing carriage return
     return encoded.replace('\n', '')
 
 
-class Credential:
+class Credential: 
     """
     A username/password pair. Use like a namedtuple.
     """
@@ -1047,8 +1047,8 @@ class PyPIConfig(configparser.RawConfigParser):
 def open_with_auth(url, opener=urllib.request.urlopen):
     """Open a urllib2 request, handling HTTP authentication"""
 
-    parsed = urllib.parse.urlparse(url)
-    scheme, netloc, path, params, query, frag = parsed
+    parsed = urllib.parse.urlparse(url) 
+    scheme, netloc, path, params, query, frag = parsed 
 
     # Double scheme does not raise on Mac OS X as revealed by a
     # failing test. We would expect "nonnumeric port". Refs #20.
@@ -1056,7 +1056,7 @@ def open_with_auth(url, opener=urllib.request.urlopen):
         raise http_client.InvalidURL("nonnumeric port: ''")
 
     if scheme in ('http', 'https'):
-        auth, address = _splituser(netloc)
+        auth, address = _splituser(netloc) 
     else:
         auth = None
 
@@ -1069,7 +1069,7 @@ def open_with_auth(url, opener=urllib.request.urlopen):
 
     if auth:
         auth = "Basic " + _encode_auth(auth)
-        parts = scheme, address, path, params, query, frag
+        parts = scheme, address, path, params, query, frag 
         new_url = urllib.parse.urlunparse(parts)
         request = urllib.request.Request(new_url)
         request.add_header("Authorization", auth)
@@ -1083,20 +1083,20 @@ def open_with_auth(url, opener=urllib.request.urlopen):
         # Put authentication info back into request URL if same host,
         # so that links found on the page will work
         s2, h2, path2, param2, query2, frag2 = urllib.parse.urlparse(fp.url)
-        if s2 == scheme and h2 == address:
+        if s2 == scheme and h2 == address: 
             parts = s2, netloc, path2, param2, query2, frag2
             fp.url = urllib.parse.urlunparse(parts)
 
     return fp
 
 
-# copy of urllib.parse._splituser from Python 3.8
-def _splituser(host):
-    """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""
-    user, delim, host = host.rpartition('@')
-    return (user if delim else None), host
-
-
+# copy of urllib.parse._splituser from Python 3.8 
+def _splituser(host): 
+    """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'.""" 
+    user, delim, host = host.rpartition('@') 
+    return (user if delim else None), host 
+ 
+ 
 # adding a timeout to avoid freezing package_index
 open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth)
 
@@ -1123,8 +1123,8 @@ def local_open(url):
                 f += '/'
             files.append('<a href="{name}">{name}</a>'.format(name=f))
         else:
-            tmpl = (
-                "<html><head><title>{url}</title>"
+            tmpl = ( 
+                "<html><head><title>{url}</title>" 
                 "</head><body>{files}</body></html>")
             body = tmpl.format(url=url, files='\n'.join(files))
         status, message = 200, "OK"
diff --git a/contrib/python/setuptools/py2/setuptools/py27compat.py b/contrib/python/setuptools/py2/setuptools/py27compat.py
index 1d57360f4e..48305a601d 100644
--- a/contrib/python/setuptools/py2/setuptools/py27compat.py
+++ b/contrib/python/setuptools/py2/setuptools/py27compat.py
@@ -2,12 +2,12 @@
 Compatibility Support for Python 2.7 and earlier
 """
 
-import sys
+import sys 
 import platform
 
-from setuptools.extern import six
-
+from setuptools.extern import six 
 
+ 
 def get_all_headers(message, key):
     """
     Given an HTTPMessage, return all headers matching a given key.
@@ -15,46 +15,46 @@ def get_all_headers(message, key):
     return message.get_all(key)
 
 
-if six.PY2:
+if six.PY2: 
     def get_all_headers(message, key):
         return message.getheaders(key)
 
 
 linux_py2_ascii = (
-    platform.system() == 'Linux' and
-    six.PY2
+    platform.system() == 'Linux' and 
+    six.PY2 
 )
 
 rmtree_safe = str if linux_py2_ascii else lambda x: x
 """Workaround for http://bugs.python.org/issue24672"""
-
-
-try:
-    from ._imp import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE
-    from ._imp import get_frozen_object, get_module
-except ImportError:
-    import imp
-    from imp import PY_COMPILED, PY_FROZEN, PY_SOURCE  # noqa
-
-    def find_module(module, paths=None):
-        """Just like 'imp.find_module()', but with package support"""
-        parts = module.split('.')
-        while parts:
-            part = parts.pop(0)
-            f, path, (suffix, mode, kind) = info = imp.find_module(part, paths)
-
-            if kind == imp.PKG_DIRECTORY:
-                parts = parts or ['__init__']
-                paths = [path]
-
-            elif parts:
-                raise ImportError("Can't find %r in %s" % (parts, module))
-
-        return info
-
-    def get_frozen_object(module, paths):
-        return imp.get_frozen_object(module)
-
-    def get_module(module, paths, info):
-        imp.load_module(module, *info)
-        return sys.modules[module]
+ 
+ 
+try: 
+    from ._imp import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE 
+    from ._imp import get_frozen_object, get_module 
+except ImportError: 
+    import imp 
+    from imp import PY_COMPILED, PY_FROZEN, PY_SOURCE  # noqa 
+ 
+    def find_module(module, paths=None): 
+        """Just like 'imp.find_module()', but with package support""" 
+        parts = module.split('.') 
+        while parts: 
+            part = parts.pop(0) 
+            f, path, (suffix, mode, kind) = info = imp.find_module(part, paths) 
+ 
+            if kind == imp.PKG_DIRECTORY: 
+                parts = parts or ['__init__'] 
+                paths = [path] 
+ 
+            elif parts: 
+                raise ImportError("Can't find %r in %s" % (parts, module)) 
+ 
+        return info 
+ 
+    def get_frozen_object(module, paths): 
+        return imp.get_frozen_object(module) 
+ 
+    def get_module(module, paths, info): 
+        imp.load_module(module, *info) 
+        return sys.modules[module] 
diff --git a/contrib/python/setuptools/py2/setuptools/py31compat.py b/contrib/python/setuptools/py2/setuptools/py31compat.py
index e1da7ee2a2..31a03da84a 100644
--- a/contrib/python/setuptools/py2/setuptools/py31compat.py
+++ b/contrib/python/setuptools/py2/setuptools/py31compat.py
@@ -1,6 +1,6 @@
-__all__ = []
+__all__ = [] 
 
-__metaclass__ = type
+__metaclass__ = type 
 
 
 try:
@@ -10,16 +10,16 @@ except ImportError:
     import shutil
     import tempfile
 
-    class TemporaryDirectory:
+    class TemporaryDirectory: 
         """
         Very simple temporary directory context manager.
         Will try to delete afterward, but will also ignore OS and similar
         errors on deletion.
         """
 
-        def __init__(self, **kwargs):
+        def __init__(self, **kwargs): 
             self.name = None  # Handle mkdtemp raising an exception
-            self.name = tempfile.mkdtemp(**kwargs)
+            self.name = tempfile.mkdtemp(**kwargs) 
 
         def __enter__(self):
             return self.name
diff --git a/contrib/python/setuptools/py2/setuptools/py33compat.py b/contrib/python/setuptools/py2/setuptools/py33compat.py
index cb69443638..767c7f8831 100644
--- a/contrib/python/setuptools/py2/setuptools/py33compat.py
+++ b/contrib/python/setuptools/py2/setuptools/py33compat.py
@@ -2,20 +2,20 @@ import dis
 import array
 import collections
 
-try:
-    import html
-except ImportError:
-    html = None
+try: 
+    import html 
+except ImportError: 
+    html = None 
 
-from setuptools.extern import six
-from setuptools.extern.six.moves import html_parser
-
-__metaclass__ = type
+from setuptools.extern import six 
+from setuptools.extern.six.moves import html_parser 
 
+__metaclass__ = type 
+ 
 OpArg = collections.namedtuple('OpArg', 'opcode arg')
 
 
-class Bytecode_compat:
+class Bytecode_compat: 
     def __init__(self, code):
         self.code = code
 
@@ -50,10 +50,10 @@ class Bytecode_compat:
 
 
 Bytecode = getattr(dis, 'Bytecode', Bytecode_compat)
-
-
-unescape = getattr(html, 'unescape', None)
-if unescape is None:
-    # HTMLParser.unescape is deprecated since Python 3.4, and will be removed
-    # from 3.9.
-    unescape = html_parser.HTMLParser().unescape
+ 
+ 
+unescape = getattr(html, 'unescape', None) 
+if unescape is None: 
+    # HTMLParser.unescape is deprecated since Python 3.4, and will be removed 
+    # from 3.9. 
+    unescape = html_parser.HTMLParser().unescape 
diff --git a/contrib/python/setuptools/py2/setuptools/py34compat.py b/contrib/python/setuptools/py2/setuptools/py34compat.py
index 3ad917222a..2e349febe7 100644
--- a/contrib/python/setuptools/py2/setuptools/py34compat.py
+++ b/contrib/python/setuptools/py2/setuptools/py34compat.py
@@ -1,13 +1,13 @@
-import importlib
-
-try:
-    import importlib.util
-except ImportError:
-    pass
-
-
-try:
-    module_from_spec = importlib.util.module_from_spec
-except AttributeError:
-    def module_from_spec(spec):
-        return spec.loader.load_module(spec.name)
+import importlib 
+ 
+try: 
+    import importlib.util 
+except ImportError: 
+    pass 
+ 
+ 
+try: 
+    module_from_spec = importlib.util.module_from_spec 
+except AttributeError: 
+    def module_from_spec(spec): 
+        return spec.loader.load_module(spec.name) 
diff --git a/contrib/python/setuptools/py2/setuptools/sandbox.py b/contrib/python/setuptools/py2/setuptools/sandbox.py
index 685f3f72e3..408af9946a 100644
--- a/contrib/python/setuptools/py2/setuptools/sandbox.py
+++ b/contrib/python/setuptools/py2/setuptools/sandbox.py
@@ -7,12 +7,12 @@ import itertools
 import re
 import contextlib
 import pickle
-import textwrap
+import textwrap 
 
-from setuptools.extern import six
-from setuptools.extern.six.moves import builtins, map
+from setuptools.extern import six 
+from setuptools.extern.six.moves import builtins, map 
 
-import pkg_resources.py31compat
+import pkg_resources.py31compat 
 
 if sys.platform.startswith('java'):
     import org.python.modules.posix.PosixModule as _os
@@ -26,7 +26,7 @@ _open = open
 from distutils.errors import DistutilsError
 from pkg_resources import working_set
 
-
+ 
 __all__ = [
     "AbstractSandbox", "DirectorySandbox", "SandboxViolation", "run_setup",
 ]
@@ -70,7 +70,7 @@ def override_temp(replacement):
     """
     Monkey-patch tempfile.tempdir with replacement, ensuring it exists
     """
-    pkg_resources.py31compat.makedirs(replacement, exist_ok=True)
+    pkg_resources.py31compat.makedirs(replacement, exist_ok=True) 
 
     saved = tempfile.tempdir
 
@@ -245,7 +245,7 @@ def run_setup(setup_script, args):
                 setup_script.encode(sys.getfilesystemencoding())
             )
 
-            with DirectorySandbox(setup_dir):
+            with DirectorySandbox(setup_dir): 
                 ns = dict(__file__=dunder_file, __name__='__main__')
                 _execfile(setup_script, ns)
         except SystemExit as v:
@@ -269,23 +269,23 @@ class AbstractSandbox:
         for name in self._attrs:
             setattr(os, name, getattr(source, name))
 
-    def __enter__(self):
-        self._copy(self)
-        if _file:
-            builtins.file = self._file
-        builtins.open = self._open
-        self._active = True
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self._active = False
-        if _file:
-            builtins.file = _file
-        builtins.open = _open
-        self._copy(_os)
-
+    def __enter__(self): 
+        self._copy(self) 
+        if _file: 
+            builtins.file = self._file 
+        builtins.open = self._open 
+        self._active = True 
+ 
+    def __exit__(self, exc_type, exc_value, traceback): 
+        self._active = False 
+        if _file: 
+            builtins.file = _file 
+        builtins.open = _open 
+        self._copy(_os) 
+ 
     def run(self, func):
         """Run 'func' under os sandboxing"""
-        with self:
+        with self: 
             return func()
 
     def _mk_dual_path_wrapper(name):
@@ -474,18 +474,18 @@ WRITE_FLAGS = functools.reduce(
 class SandboxViolation(DistutilsError):
     """A setup script attempted to modify the filesystem outside the sandbox"""
 
-    tmpl = textwrap.dedent("""
-        SandboxViolation: {cmd}{args!r} {kwargs}
+    tmpl = textwrap.dedent(""" 
+        SandboxViolation: {cmd}{args!r} {kwargs} 
 
-        The package setup script has attempted to modify files on your system
-        that are not within the EasyInstall build area, and has been aborted.
+        The package setup script has attempted to modify files on your system 
+        that are not within the EasyInstall build area, and has been aborted. 
 
-        This package cannot be safely installed by EasyInstall, and may not
-        support alternate installation locations even if you run its setup
-        script by hand.  Please inform the package's author and the EasyInstall
-        maintainers to find out if a fix or workaround is available.
-        """).lstrip()
+        This package cannot be safely installed by EasyInstall, and may not 
+        support alternate installation locations even if you run its setup 
+        script by hand.  Please inform the package's author and the EasyInstall 
+        maintainers to find out if a fix or workaround is available. 
+        """).lstrip() 
 
-    def __str__(self):
-        cmd, args, kwargs = self.args
-        return self.tmpl.format(**locals())
+    def __str__(self): 
+        cmd, args, kwargs = self.args 
+        return self.tmpl.format(**locals()) 
diff --git a/contrib/python/setuptools/py2/setuptools/site-patch.py b/contrib/python/setuptools/py2/setuptools/site-patch.py
index 40b00de0a7..b5e4db8e82 100644
--- a/contrib/python/setuptools/py2/setuptools/site-patch.py
+++ b/contrib/python/setuptools/py2/setuptools/site-patch.py
@@ -23,7 +23,7 @@ def __boot():
                 break
         else:
             try:
-                import imp  # Avoid import loop in Python 3
+                import imp  # Avoid import loop in Python 3 
                 stream, path, descr = imp.find_module('site', [item])
             except ImportError:
                 continue
diff --git a/contrib/python/setuptools/py2/setuptools/ssl_support.py b/contrib/python/setuptools/py2/setuptools/ssl_support.py
index 226db694bb..3472c2f10f 100644
--- a/contrib/python/setuptools/py2/setuptools/ssl_support.py
+++ b/contrib/python/setuptools/py2/setuptools/ssl_support.py
@@ -4,7 +4,7 @@ import atexit
 import re
 import functools
 
-from setuptools.extern.six.moves import urllib, http_client, map, filter
+from setuptools.extern.six.moves import urllib, http_client, map, filter 
 
 from pkg_resources import ResolutionError, ExtractionError
 
@@ -59,7 +59,7 @@ if not match_hostname:
     def _dnsname_match(dn, hostname, max_wildcards=1):
         """Matching according to RFC 6125, section 6.4.3
 
-        https://tools.ietf.org/html/rfc6125#section-6.4.3
+        https://tools.ietf.org/html/rfc6125#section-6.4.3 
         """
         pats = []
         if not dn:
@@ -186,14 +186,14 @@ class VerifyingHTTPSConn(HTTPSConnection):
         else:
             actual_host = self.host
 
-        if hasattr(ssl, 'create_default_context'):
-            ctx = ssl.create_default_context(cafile=self.ca_bundle)
-            self.sock = ctx.wrap_socket(sock, server_hostname=actual_host)
-        else:
-            # This is for python < 2.7.9 and < 3.4?
-            self.sock = ssl.wrap_socket(
-                sock, cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.ca_bundle
-            )
+        if hasattr(ssl, 'create_default_context'): 
+            ctx = ssl.create_default_context(cafile=self.ca_bundle) 
+            self.sock = ctx.wrap_socket(sock, server_hostname=actual_host) 
+        else: 
+            # This is for python < 2.7.9 and < 3.4? 
+            self.sock = ssl.wrap_socket( 
+                sock, cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.ca_bundle 
+            ) 
         try:
             match_hostname(self.sock.getpeercert(), actual_host)
         except CertificateError:
diff --git a/contrib/python/setuptools/py2/setuptools/unicode_utils.py b/contrib/python/setuptools/py2/setuptools/unicode_utils.py
index 7c63efd20b..510683ea36 100644
--- a/contrib/python/setuptools/py2/setuptools/unicode_utils.py
+++ b/contrib/python/setuptools/py2/setuptools/unicode_utils.py
@@ -1,7 +1,7 @@
 import unicodedata
 import sys
 
-from setuptools.extern import six
+from setuptools.extern import six 
 
 
 # HFS Plus uses decomposed UTF-8
diff --git a/contrib/python/setuptools/py2/setuptools/wheel.py b/contrib/python/setuptools/py2/setuptools/wheel.py
index 025aaa828a..387d6eb4ee 100644
--- a/contrib/python/setuptools/py2/setuptools/wheel.py
+++ b/contrib/python/setuptools/py2/setuptools/wheel.py
@@ -1,220 +1,220 @@
-"""Wheels support."""
-
-from distutils.util import get_platform
-from distutils import log
-import email
-import itertools
-import os
-import posixpath
-import re
-import zipfile
-
-import pkg_resources
-import setuptools
-from pkg_resources import parse_version
-from setuptools.extern.packaging.tags import sys_tags
-from setuptools.extern.packaging.utils import canonicalize_name
-from setuptools.extern.six import PY3
-from setuptools.command.egg_info import write_requirements
-
-
-__metaclass__ = type
-
-
-WHEEL_NAME = re.compile(
-    r"""^(?P<project_name>.+?)-(?P<version>\d.*?)
-    ((-(?P<build>\d.*?))?-(?P<py_version>.+?)-(?P<abi>.+?)-(?P<platform>.+?)
-    )\.whl$""",
-    re.VERBOSE).match
-
-NAMESPACE_PACKAGE_INIT = '''\
-try:
-    __import__('pkg_resources').declare_namespace(__name__)
-except ImportError:
-    __path__ = __import__('pkgutil').extend_path(__path__, __name__)
-'''
-
-
-def unpack(src_dir, dst_dir):
-    '''Move everything under `src_dir` to `dst_dir`, and delete the former.'''
-    for dirpath, dirnames, filenames in os.walk(src_dir):
-        subdir = os.path.relpath(dirpath, src_dir)
-        for f in filenames:
-            src = os.path.join(dirpath, f)
-            dst = os.path.join(dst_dir, subdir, f)
-            os.renames(src, dst)
-        for n, d in reversed(list(enumerate(dirnames))):
-            src = os.path.join(dirpath, d)
-            dst = os.path.join(dst_dir, subdir, d)
-            if not os.path.exists(dst):
-                # Directory does not exist in destination,
-                # rename it and prune it from os.walk list.
-                os.renames(src, dst)
-                del dirnames[n]
-    # Cleanup.
-    for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True):
-        assert not filenames
-        os.rmdir(dirpath)
-
-
-class Wheel:
-
-    def __init__(self, filename):
-        match = WHEEL_NAME(os.path.basename(filename))
-        if match is None:
-            raise ValueError('invalid wheel name: %r' % filename)
-        self.filename = filename
-        for k, v in match.groupdict().items():
-            setattr(self, k, v)
-
-    def tags(self):
-        '''List tags (py_version, abi, platform) supported by this wheel.'''
-        return itertools.product(
-            self.py_version.split('.'),
-            self.abi.split('.'),
-            self.platform.split('.'),
-        )
-
-    def is_compatible(self):
-        '''Is the wheel is compatible with the current platform?'''
-        supported_tags = set((t.interpreter, t.abi, t.platform) for t in sys_tags())
-        return next((True for t in self.tags() if t in supported_tags), False)
-
-    def egg_name(self):
-        return pkg_resources.Distribution(
-            project_name=self.project_name, version=self.version,
-            platform=(None if self.platform == 'any' else get_platform()),
-        ).egg_name() + '.egg'
-
-    def get_dist_info(self, zf):
-        # find the correct name of the .dist-info dir in the wheel file
-        for member in zf.namelist():
-            dirname = posixpath.dirname(member)
-            if (dirname.endswith('.dist-info') and
-                    canonicalize_name(dirname).startswith(
-                        canonicalize_name(self.project_name))):
-                return dirname
-        raise ValueError("unsupported wheel format. .dist-info not found")
-
-    def install_as_egg(self, destination_eggdir):
-        '''Install wheel as an egg directory.'''
-        with zipfile.ZipFile(self.filename) as zf:
-            self._install_as_egg(destination_eggdir, zf)
-
-    def _install_as_egg(self, destination_eggdir, zf):
-        dist_basename = '%s-%s' % (self.project_name, self.version)
-        dist_info = self.get_dist_info(zf)
-        dist_data = '%s.data' % dist_basename
-        egg_info = os.path.join(destination_eggdir, 'EGG-INFO')
-
-        self._convert_metadata(zf, destination_eggdir, dist_info, egg_info)
-        self._move_data_entries(destination_eggdir, dist_data)
-        self._fix_namespace_packages(egg_info, destination_eggdir)
-
-    @staticmethod
-    def _convert_metadata(zf, destination_eggdir, dist_info, egg_info):
-        def get_metadata(name):
-            with zf.open(posixpath.join(dist_info, name)) as fp:
-                value = fp.read().decode('utf-8') if PY3 else fp.read()
-                return email.parser.Parser().parsestr(value)
-
-        wheel_metadata = get_metadata('WHEEL')
-        # Check wheel format version is supported.
-        wheel_version = parse_version(wheel_metadata.get('Wheel-Version'))
-        wheel_v1 = (
-            parse_version('1.0') <= wheel_version < parse_version('2.0dev0')
-        )
-        if not wheel_v1:
-            raise ValueError(
-                'unsupported wheel format version: %s' % wheel_version)
-        # Extract to target directory.
-        os.mkdir(destination_eggdir)
-        zf.extractall(destination_eggdir)
-        # Convert metadata.
-        dist_info = os.path.join(destination_eggdir, dist_info)
-        dist = pkg_resources.Distribution.from_location(
-            destination_eggdir, dist_info,
-            metadata=pkg_resources.PathMetadata(destination_eggdir, dist_info),
-        )
-
-        # Note: Evaluate and strip markers now,
-        # as it's difficult to convert back from the syntax:
-        # foobar; "linux" in sys_platform and extra == 'test'
-        def raw_req(req):
-            req.marker = None
-            return str(req)
-        install_requires = list(sorted(map(raw_req, dist.requires())))
-        extras_require = {
-            extra: sorted(
-                req
-                for req in map(raw_req, dist.requires((extra,)))
-                if req not in install_requires
-            )
-            for extra in dist.extras
-        }
-        os.rename(dist_info, egg_info)
-        os.rename(
-            os.path.join(egg_info, 'METADATA'),
-            os.path.join(egg_info, 'PKG-INFO'),
-        )
-        setup_dist = setuptools.Distribution(
-            attrs=dict(
-                install_requires=install_requires,
-                extras_require=extras_require,
-            ),
-        )
-        # Temporarily disable info traces.
-        log_threshold = log._global_log.threshold
-        log.set_threshold(log.WARN)
-        try:
-            write_requirements(
-                setup_dist.get_command_obj('egg_info'),
-                None,
-                os.path.join(egg_info, 'requires.txt'),
-            )
-        finally:
-            log.set_threshold(log_threshold)
-
-    @staticmethod
-    def _move_data_entries(destination_eggdir, dist_data):
-        """Move data entries to their correct location."""
-        dist_data = os.path.join(destination_eggdir, dist_data)
-        dist_data_scripts = os.path.join(dist_data, 'scripts')
-        if os.path.exists(dist_data_scripts):
-            egg_info_scripts = os.path.join(
-                destination_eggdir, 'EGG-INFO', 'scripts')
-            os.mkdir(egg_info_scripts)
-            for entry in os.listdir(dist_data_scripts):
-                # Remove bytecode, as it's not properly handled
-                # during easy_install scripts install phase.
-                if entry.endswith('.pyc'):
-                    os.unlink(os.path.join(dist_data_scripts, entry))
-                else:
-                    os.rename(
-                        os.path.join(dist_data_scripts, entry),
-                        os.path.join(egg_info_scripts, entry),
-                    )
-            os.rmdir(dist_data_scripts)
-        for subdir in filter(os.path.exists, (
-            os.path.join(dist_data, d)
-            for d in ('data', 'headers', 'purelib', 'platlib')
-        )):
-            unpack(subdir, destination_eggdir)
-        if os.path.exists(dist_data):
-            os.rmdir(dist_data)
-
-    @staticmethod
-    def _fix_namespace_packages(egg_info, destination_eggdir):
-        namespace_packages = os.path.join(
-            egg_info, 'namespace_packages.txt')
-        if os.path.exists(namespace_packages):
-            with open(namespace_packages) as fp:
-                namespace_packages = fp.read().split()
-            for mod in namespace_packages:
-                mod_dir = os.path.join(destination_eggdir, *mod.split('.'))
-                mod_init = os.path.join(mod_dir, '__init__.py')
-                if not os.path.exists(mod_dir):
-                    os.mkdir(mod_dir)
-                if not os.path.exists(mod_init):
-                    with open(mod_init, 'w') as fp:
-                        fp.write(NAMESPACE_PACKAGE_INIT)
+"""Wheels support.""" 
+ 
+from distutils.util import get_platform 
+from distutils import log 
+import email 
+import itertools 
+import os 
+import posixpath 
+import re 
+import zipfile 
+ 
+import pkg_resources 
+import setuptools 
+from pkg_resources import parse_version 
+from setuptools.extern.packaging.tags import sys_tags 
+from setuptools.extern.packaging.utils import canonicalize_name 
+from setuptools.extern.six import PY3 
+from setuptools.command.egg_info import write_requirements 
+ 
+ 
+__metaclass__ = type 
+ 
+ 
+WHEEL_NAME = re.compile( 
+    r"""^(?P<project_name>.+?)-(?P<version>\d.*?) 
+    ((-(?P<build>\d.*?))?-(?P<py_version>.+?)-(?P<abi>.+?)-(?P<platform>.+?) 
+    )\.whl$""", 
+    re.VERBOSE).match 
+ 
+NAMESPACE_PACKAGE_INIT = '''\ 
+try: 
+    __import__('pkg_resources').declare_namespace(__name__) 
+except ImportError: 
+    __path__ = __import__('pkgutil').extend_path(__path__, __name__) 
+''' 
+ 
+ 
+def unpack(src_dir, dst_dir): 
+    '''Move everything under `src_dir` to `dst_dir`, and delete the former.''' 
+    for dirpath, dirnames, filenames in os.walk(src_dir): 
+        subdir = os.path.relpath(dirpath, src_dir) 
+        for f in filenames: 
+            src = os.path.join(dirpath, f) 
+            dst = os.path.join(dst_dir, subdir, f) 
+            os.renames(src, dst) 
+        for n, d in reversed(list(enumerate(dirnames))): 
+            src = os.path.join(dirpath, d) 
+            dst = os.path.join(dst_dir, subdir, d) 
+            if not os.path.exists(dst): 
+                # Directory does not exist in destination, 
+                # rename it and prune it from os.walk list. 
+                os.renames(src, dst) 
+                del dirnames[n] 
+    # Cleanup. 
+    for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True): 
+        assert not filenames 
+        os.rmdir(dirpath) 
+ 
+ 
+class Wheel: 
+ 
+    def __init__(self, filename): 
+        match = WHEEL_NAME(os.path.basename(filename)) 
+        if match is None: 
+            raise ValueError('invalid wheel name: %r' % filename) 
+        self.filename = filename 
+        for k, v in match.groupdict().items(): 
+            setattr(self, k, v) 
+ 
+    def tags(self): 
+        '''List tags (py_version, abi, platform) supported by this wheel.''' 
+        return itertools.product( 
+            self.py_version.split('.'), 
+            self.abi.split('.'), 
+            self.platform.split('.'), 
+        ) 
+ 
+    def is_compatible(self): 
+        '''Is the wheel is compatible with the current platform?''' 
+        supported_tags = set((t.interpreter, t.abi, t.platform) for t in sys_tags()) 
+        return next((True for t in self.tags() if t in supported_tags), False) 
+ 
+    def egg_name(self): 
+        return pkg_resources.Distribution( 
+            project_name=self.project_name, version=self.version, 
+            platform=(None if self.platform == 'any' else get_platform()), 
+        ).egg_name() + '.egg' 
+ 
+    def get_dist_info(self, zf): 
+        # find the correct name of the .dist-info dir in the wheel file 
+        for member in zf.namelist(): 
+            dirname = posixpath.dirname(member) 
+            if (dirname.endswith('.dist-info') and 
+                    canonicalize_name(dirname).startswith( 
+                        canonicalize_name(self.project_name))): 
+                return dirname 
+        raise ValueError("unsupported wheel format. .dist-info not found") 
+ 
+    def install_as_egg(self, destination_eggdir): 
+        '''Install wheel as an egg directory.''' 
+        with zipfile.ZipFile(self.filename) as zf: 
+            self._install_as_egg(destination_eggdir, zf) 
+ 
+    def _install_as_egg(self, destination_eggdir, zf): 
+        dist_basename = '%s-%s' % (self.project_name, self.version) 
+        dist_info = self.get_dist_info(zf) 
+        dist_data = '%s.data' % dist_basename 
+        egg_info = os.path.join(destination_eggdir, 'EGG-INFO') 
+ 
+        self._convert_metadata(zf, destination_eggdir, dist_info, egg_info) 
+        self._move_data_entries(destination_eggdir, dist_data) 
+        self._fix_namespace_packages(egg_info, destination_eggdir) 
+ 
+    @staticmethod 
+    def _convert_metadata(zf, destination_eggdir, dist_info, egg_info): 
+        def get_metadata(name): 
+            with zf.open(posixpath.join(dist_info, name)) as fp: 
+                value = fp.read().decode('utf-8') if PY3 else fp.read() 
+                return email.parser.Parser().parsestr(value) 
+ 
+        wheel_metadata = get_metadata('WHEEL') 
+        # Check wheel format version is supported. 
+        wheel_version = parse_version(wheel_metadata.get('Wheel-Version')) 
+        wheel_v1 = ( 
+            parse_version('1.0') <= wheel_version < parse_version('2.0dev0') 
+        ) 
+        if not wheel_v1: 
+            raise ValueError( 
+                'unsupported wheel format version: %s' % wheel_version) 
+        # Extract to target directory. 
+        os.mkdir(destination_eggdir) 
+        zf.extractall(destination_eggdir) 
+        # Convert metadata. 
+        dist_info = os.path.join(destination_eggdir, dist_info) 
+        dist = pkg_resources.Distribution.from_location( 
+            destination_eggdir, dist_info, 
+            metadata=pkg_resources.PathMetadata(destination_eggdir, dist_info), 
+        ) 
+ 
+        # Note: Evaluate and strip markers now, 
+        # as it's difficult to convert back from the syntax: 
+        # foobar; "linux" in sys_platform and extra == 'test' 
+        def raw_req(req): 
+            req.marker = None 
+            return str(req) 
+        install_requires = list(sorted(map(raw_req, dist.requires()))) 
+        extras_require = { 
+            extra: sorted( 
+                req 
+                for req in map(raw_req, dist.requires((extra,))) 
+                if req not in install_requires 
+            ) 
+            for extra in dist.extras 
+        } 
+        os.rename(dist_info, egg_info) 
+        os.rename( 
+            os.path.join(egg_info, 'METADATA'), 
+            os.path.join(egg_info, 'PKG-INFO'), 
+        ) 
+        setup_dist = setuptools.Distribution( 
+            attrs=dict( 
+                install_requires=install_requires, 
+                extras_require=extras_require, 
+            ), 
+        ) 
+        # Temporarily disable info traces. 
+        log_threshold = log._global_log.threshold 
+        log.set_threshold(log.WARN) 
+        try: 
+            write_requirements( 
+                setup_dist.get_command_obj('egg_info'), 
+                None, 
+                os.path.join(egg_info, 'requires.txt'), 
+            ) 
+        finally: 
+            log.set_threshold(log_threshold) 
+ 
+    @staticmethod 
+    def _move_data_entries(destination_eggdir, dist_data): 
+        """Move data entries to their correct location.""" 
+        dist_data = os.path.join(destination_eggdir, dist_data) 
+        dist_data_scripts = os.path.join(dist_data, 'scripts') 
+        if os.path.exists(dist_data_scripts): 
+            egg_info_scripts = os.path.join( 
+                destination_eggdir, 'EGG-INFO', 'scripts') 
+            os.mkdir(egg_info_scripts) 
+            for entry in os.listdir(dist_data_scripts): 
+                # Remove bytecode, as it's not properly handled 
+                # during easy_install scripts install phase. 
+                if entry.endswith('.pyc'): 
+                    os.unlink(os.path.join(dist_data_scripts, entry)) 
+                else: 
+                    os.rename( 
+                        os.path.join(dist_data_scripts, entry), 
+                        os.path.join(egg_info_scripts, entry), 
+                    ) 
+            os.rmdir(dist_data_scripts) 
+        for subdir in filter(os.path.exists, ( 
+            os.path.join(dist_data, d) 
+            for d in ('data', 'headers', 'purelib', 'platlib') 
+        )): 
+            unpack(subdir, destination_eggdir) 
+        if os.path.exists(dist_data): 
+            os.rmdir(dist_data) 
+ 
+    @staticmethod 
+    def _fix_namespace_packages(egg_info, destination_eggdir): 
+        namespace_packages = os.path.join( 
+            egg_info, 'namespace_packages.txt') 
+        if os.path.exists(namespace_packages): 
+            with open(namespace_packages) as fp: 
+                namespace_packages = fp.read().split() 
+            for mod in namespace_packages: 
+                mod_dir = os.path.join(destination_eggdir, *mod.split('.')) 
+                mod_init = os.path.join(mod_dir, '__init__.py') 
+                if not os.path.exists(mod_dir): 
+                    os.mkdir(mod_dir) 
+                if not os.path.exists(mod_init): 
+                    with open(mod_init, 'w') as fp: 
+                        fp.write(NAMESPACE_PACKAGE_INIT) 
diff --git a/contrib/python/setuptools/py2/ya.make b/contrib/python/setuptools/py2/ya.make
index 4c36dcf1ab..7cbcf6b4ba 100644
--- a/contrib/python/setuptools/py2/ya.make
+++ b/contrib/python/setuptools/py2/ya.make
@@ -1,10 +1,10 @@
 PY2_LIBRARY()
 
-LICENSE(MIT)
+LICENSE(MIT) 
 
 OWNER(g:python-contrib borman orivej)
 
-VERSION(44.1.1)
+VERSION(44.1.1) 
 
 PEERDIR(
     library/python/resource
@@ -20,40 +20,40 @@ PY_SRCS(
     TOP_LEVEL
     easy_install.py
     pkg_resources/__init__.py
-    pkg_resources/_vendor/__init__.py
-    pkg_resources/_vendor/appdirs.py
-    pkg_resources/_vendor/packaging/__about__.py
-    pkg_resources/_vendor/packaging/__init__.py
-    pkg_resources/_vendor/packaging/_compat.py
-    pkg_resources/_vendor/packaging/_structures.py
-    pkg_resources/_vendor/packaging/markers.py
-    pkg_resources/_vendor/packaging/requirements.py
-    pkg_resources/_vendor/packaging/specifiers.py
-    pkg_resources/_vendor/packaging/utils.py
-    pkg_resources/_vendor/packaging/version.py
-    pkg_resources/_vendor/pyparsing.py
-    pkg_resources/_vendor/six.py
-    pkg_resources/extern/__init__.py
-    pkg_resources/py31compat.py
+    pkg_resources/_vendor/__init__.py 
+    pkg_resources/_vendor/appdirs.py 
+    pkg_resources/_vendor/packaging/__about__.py 
+    pkg_resources/_vendor/packaging/__init__.py 
+    pkg_resources/_vendor/packaging/_compat.py 
+    pkg_resources/_vendor/packaging/_structures.py 
+    pkg_resources/_vendor/packaging/markers.py 
+    pkg_resources/_vendor/packaging/requirements.py 
+    pkg_resources/_vendor/packaging/specifiers.py 
+    pkg_resources/_vendor/packaging/utils.py 
+    pkg_resources/_vendor/packaging/version.py 
+    pkg_resources/_vendor/pyparsing.py 
+    pkg_resources/_vendor/six.py 
+    pkg_resources/extern/__init__.py 
+    pkg_resources/py31compat.py 
     setuptools/__init__.py
-    setuptools/_deprecation_warning.py
-    setuptools/_imp.py
-    setuptools/_vendor/__init__.py
-    setuptools/_vendor/ordered_set.py
-    setuptools/_vendor/packaging/__about__.py
-    setuptools/_vendor/packaging/__init__.py
-    setuptools/_vendor/packaging/_compat.py
-    setuptools/_vendor/packaging/_structures.py
-    setuptools/_vendor/packaging/markers.py
-    setuptools/_vendor/packaging/requirements.py
-    setuptools/_vendor/packaging/specifiers.py
-    setuptools/_vendor/packaging/tags.py
-    setuptools/_vendor/packaging/utils.py
-    setuptools/_vendor/packaging/version.py
-    setuptools/_vendor/pyparsing.py
-    setuptools/_vendor/six.py
+    setuptools/_deprecation_warning.py 
+    setuptools/_imp.py 
+    setuptools/_vendor/__init__.py 
+    setuptools/_vendor/ordered_set.py 
+    setuptools/_vendor/packaging/__about__.py 
+    setuptools/_vendor/packaging/__init__.py 
+    setuptools/_vendor/packaging/_compat.py 
+    setuptools/_vendor/packaging/_structures.py 
+    setuptools/_vendor/packaging/markers.py 
+    setuptools/_vendor/packaging/requirements.py 
+    setuptools/_vendor/packaging/specifiers.py 
+    setuptools/_vendor/packaging/tags.py 
+    setuptools/_vendor/packaging/utils.py 
+    setuptools/_vendor/packaging/version.py 
+    setuptools/_vendor/pyparsing.py 
+    setuptools/_vendor/six.py 
     setuptools/archive_util.py
-    setuptools/build_meta.py
+    setuptools/build_meta.py 
     setuptools/command/__init__.py
     setuptools/command/alias.py
     setuptools/command/bdist_egg.py
@@ -63,7 +63,7 @@ PY_SRCS(
     setuptools/command/build_ext.py
     setuptools/command/build_py.py
     setuptools/command/develop.py
-    setuptools/command/dist_info.py
+    setuptools/command/dist_info.py 
     setuptools/command/easy_install.py
     setuptools/command/egg_info.py
     setuptools/command/install.py
@@ -83,11 +83,11 @@ PY_SRCS(
     setuptools/dep_util.py
     setuptools/depends.py
     setuptools/dist.py
-    setuptools/errors.py
+    setuptools/errors.py 
     setuptools/extension.py
-    setuptools/extern/__init__.py
+    setuptools/extern/__init__.py 
     setuptools/glob.py
-    setuptools/installer.py
+    setuptools/installer.py 
     setuptools/launch.py
     setuptools/lib2to3_ex.py
     setuptools/monkey.py
@@ -97,21 +97,21 @@ PY_SRCS(
     setuptools/py27compat.py
     setuptools/py31compat.py
     setuptools/py33compat.py
-    setuptools/py34compat.py
+    setuptools/py34compat.py 
     setuptools/sandbox.py
     setuptools/site-patch.py
     setuptools/ssl_support.py
     setuptools/unicode_utils.py
     setuptools/version.py
-    setuptools/wheel.py
+    setuptools/wheel.py 
     setuptools/windows_support.py
 )
 
-RESOURCE_FILES(
-    PREFIX contrib/python/setuptools/py2/
-    .dist-info/METADATA
-    .dist-info/entry_points.txt
-    .dist-info/top_level.txt
+RESOURCE_FILES( 
+    PREFIX contrib/python/setuptools/py2/ 
+    .dist-info/METADATA 
+    .dist-info/entry_points.txt 
+    .dist-info/top_level.txt 
 )
 
 END()