Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.

39 files changed, 10259 insertions, 10259 deletions

diff --git a/contrib/python/setuptools/py2/pkg_resources/__init__.py b/contrib/python/setuptools/py2/pkg_resources/__init__.py
index 649a2ce651..7f5c87e858 100644
--- a/contrib/python/setuptools/py2/pkg_resources/__init__.py
+++ b/contrib/python/setuptools/py2/pkg_resources/__init__.py
@@ -1,81 +1,81 @@
 # coding: utf-8
-"""
-Package resource API
---------------------
-
-A resource is a logical file contained within a package, or a logical
-subdirectory thereof.  The package resource API expects resource names
-to have their path parts separated with ``/``, *not* whatever the local
-path separator is.  Do not use os.path operations to manipulate resource
-names being passed into the API.
-
-The package resource API is designed to work with normal filesystem packages,
-.egg files, and unpacked .egg files.  It can also work in a limited way with
-.zip files and with custom PEP 302 loaders that support the ``get_data()``
-method.
-"""
-
-from __future__ import absolute_import
-
-import sys
-import os
-import io
-import time
-import re
-import types
-import zipfile
-import zipimport
-import warnings
-import stat
-import functools
-import pkgutil
-import operator
-import platform
-import collections
-import plistlib
-import email.parser
+""" 
+Package resource API 
+-------------------- 
+ 
+A resource is a logical file contained within a package, or a logical 
+subdirectory thereof.  The package resource API expects resource names 
+to have their path parts separated with ``/``, *not* whatever the local 
+path separator is.  Do not use os.path operations to manipulate resource 
+names being passed into the API. 
+ 
+The package resource API is designed to work with normal filesystem packages, 
+.egg files, and unpacked .egg files.  It can also work in a limited way with 
+.zip files and with custom PEP 302 loaders that support the ``get_data()`` 
+method. 
+""" 
+ 
+from __future__ import absolute_import 
+ 
+import sys 
+import os 
+import io 
+import time 
+import re 
+import types 
+import zipfile 
+import zipimport 
+import warnings 
+import stat 
+import functools 
+import pkgutil 
+import operator 
+import platform 
+import collections 
+import plistlib 
+import email.parser 
 import errno
-import tempfile
-import textwrap
+import tempfile 
+import textwrap 
 import itertools
 import inspect
 import ntpath
 import posixpath
-from pkgutil import get_importer
-
-try:
-    import _imp
-except ImportError:
-    # Python 3.2 compatibility
-    import imp as _imp
-
+from pkgutil import get_importer 
+ 
+try: 
+    import _imp 
+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
 
-# capture these to bypass sandboxing
-from os import utime
-try:
-    from os import mkdir, rename, unlink
-    WRITE_SUPPORT = True
-except ImportError:
-    # no write support, probably under GAE
-    WRITE_SUPPORT = False
-
-from os import open as os_open
-from os.path import isdir, split
-
-try:
-    import importlib.machinery as importlib_machinery
-    # access attribute to force import under delayed import mechanisms.
-    importlib_machinery.__name__
-except ImportError:
-    importlib_machinery = None
-
+# capture these to bypass sandboxing 
+from os import utime 
+try: 
+    from os import mkdir, rename, unlink 
+    WRITE_SUPPORT = True 
+except ImportError: 
+    # no write support, probably under GAE 
+    WRITE_SUPPORT = False 
+ 
+from os import open as os_open 
+from os.path import isdir, split 
+ 
+try: 
+    import importlib.machinery as importlib_machinery 
+    # access attribute to force import under delayed import mechanisms. 
+    importlib_machinery.__name__ 
+except ImportError: 
+    importlib_machinery = None 
+ 
 from . import py31compat
 from pkg_resources.extern import appdirs
 from pkg_resources.extern import packaging
@@ -83,8 +83,8 @@ __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
 
 
@@ -96,10 +96,10 @@ if six.PY2:
     PermissionError = None
     NotADirectoryError = None
 
-# declare some globals that will be defined later to
-# satisfy the linters.
-require = None
-working_set = 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
@@ -115,827 +115,827 @@ resource_exists = None
 _distribution_finders = None
 _namespace_handlers = None
 _namespace_packages = None
-
-
-class PEP440Warning(RuntimeWarning):
-    """
-    Used when there is an issue with a version or specifier not complying with
-    PEP 440.
-    """
-
-
-def parse_version(v):
-    try:
+ 
+ 
+class PEP440Warning(RuntimeWarning): 
+    """ 
+    Used when there is an issue with a version or specifier not complying with 
+    PEP 440. 
+    """ 
+ 
+ 
+def parse_version(v): 
+    try: 
         return packaging.version.Version(v)
-    except packaging.version.InvalidVersion:
+    except packaging.version.InvalidVersion: 
         return packaging.version.LegacyVersion(v)
-
-
-_state_vars = {}
-
-
-def _declare_state(vartype, **kw):
-    globals().update(kw)
-    _state_vars.update(dict.fromkeys(kw, vartype))
-
-
-def __getstate__():
-    state = {}
-    g = globals()
-    for k, v in _state_vars.items():
+ 
+ 
+_state_vars = {} 
+ 
+
+def _declare_state(vartype, **kw): 
+    globals().update(kw) 
+    _state_vars.update(dict.fromkeys(kw, vartype)) 
+ 
+
+def __getstate__(): 
+    state = {} 
+    g = globals() 
+    for k, v in _state_vars.items(): 
         state[k] = g['_sget_' + v](g[k])
-    return state
-
+    return state 
+ 
 
-def __setstate__(state):
-    g = globals()
-    for k, v in state.items():
+def __setstate__(state): 
+    g = globals() 
+    for k, v in state.items(): 
         g['_sset_' + _state_vars[k]](k, g[k], v)
-    return state
-
-
-def _sget_dict(val):
-    return val.copy()
-
-
-def _sset_dict(key, ob, state):
-    ob.clear()
-    ob.update(state)
-
-
-def _sget_object(val):
-    return val.__getstate__()
-
-
-def _sset_object(key, ob, state):
-    ob.__setstate__(state)
-
-
-_sget_none = _sset_none = lambda *args: None
-
-
-def get_supported_platform():
-    """Return this platform's maximum compatible version.
-
-    distutils.util.get_platform() normally reports the minimum version
-    of Mac OS X that would be required to *use* extensions produced by
-    distutils.  But what we want when checking compatibility is to know the
-    version of Mac OS X that we are *running*.  To allow usage of packages that
-    explicitly require a newer version of Mac OS X, we must also know the
-    current version of the OS.
-
-    If this condition occurs for any other platform with a version in its
-    platform strings, this function should be extended accordingly.
-    """
-    plat = get_build_platform()
-    m = macosVersionString.match(plat)
-    if m is not None and sys.platform == "darwin":
-        try:
-            plat = 'macosx-%s-%s' % ('.'.join(_macosx_vers()[:2]), m.group(3))
-        except ValueError:
-            # not Mac OS X
-            pass
-    return plat
-
-
-__all__ = [
-    # Basic resource access and distribution/entry point discovery
+    return state 
+ 
+
+def _sget_dict(val): 
+    return val.copy() 
+ 
+
+def _sset_dict(key, ob, state): 
+    ob.clear() 
+    ob.update(state) 
+ 
+
+def _sget_object(val): 
+    return val.__getstate__() 
+ 
+
+def _sset_object(key, ob, state): 
+    ob.__setstate__(state) 
+ 
+
+_sget_none = _sset_none = lambda *args: None 
+ 
+ 
+def get_supported_platform(): 
+    """Return this platform's maximum compatible version. 
+ 
+    distutils.util.get_platform() normally reports the minimum version 
+    of Mac OS X that would be required to *use* extensions produced by 
+    distutils.  But what we want when checking compatibility is to know the 
+    version of Mac OS X that we are *running*.  To allow usage of packages that 
+    explicitly require a newer version of Mac OS X, we must also know the 
+    current version of the OS. 
+ 
+    If this condition occurs for any other platform with a version in its 
+    platform strings, this function should be extended accordingly. 
+    """ 
+    plat = get_build_platform() 
+    m = macosVersionString.match(plat) 
+    if m is not None and sys.platform == "darwin": 
+        try: 
+            plat = 'macosx-%s-%s' % ('.'.join(_macosx_vers()[:2]), m.group(3)) 
+        except ValueError: 
+            # not Mac OS X 
+            pass 
+    return plat 
+ 
+
+__all__ = [ 
+    # Basic resource access and distribution/entry point discovery 
     'require', 'run_script', 'get_provider', 'get_distribution',
-    'load_entry_point', 'get_entry_map', 'get_entry_info',
-    'iter_entry_points',
-    'resource_string', 'resource_stream', 'resource_filename',
-    'resource_listdir', 'resource_exists', 'resource_isdir',
-
-    # Environmental control
-    'declare_namespace', 'working_set', 'add_activation_listener',
-    'find_distributions', 'set_extraction_path', 'cleanup_resources',
-    'get_default_cache',
-
-    # Primary implementation classes
-    'Environment', 'WorkingSet', 'ResourceManager',
-    'Distribution', 'Requirement', 'EntryPoint',
-
-    # Exceptions
-    'ResolutionError', 'VersionConflict', 'DistributionNotFound',
-    'UnknownExtra', 'ExtractionError',
-
-    # Warnings
-    'PEP440Warning',
-
-    # Parsing functions and string utilities
-    'parse_requirements', 'parse_version', 'safe_name', 'safe_version',
-    'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',
-    'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',
-
-    # filesystem utilities
-    'ensure_directory', 'normalize_path',
-
-    # Distribution "precedence" constants
-    'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',
-
-    # "Provider" interfaces, implementations, and registration/lookup APIs
-    'IMetadataProvider', 'IResourceProvider', 'FileMetadata',
-    'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',
-    'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',
-    'register_finder', 'register_namespace_handler', 'register_loader_type',
-    'fixup_namespace_packages', 'get_importer',
-
+    'load_entry_point', 'get_entry_map', 'get_entry_info', 
+    'iter_entry_points', 
+    'resource_string', 'resource_stream', 'resource_filename', 
+    'resource_listdir', 'resource_exists', 'resource_isdir', 
+ 
+    # Environmental control 
+    'declare_namespace', 'working_set', 'add_activation_listener', 
+    'find_distributions', 'set_extraction_path', 'cleanup_resources', 
+    'get_default_cache', 
+ 
+    # Primary implementation classes 
+    'Environment', 'WorkingSet', 'ResourceManager', 
+    'Distribution', 'Requirement', 'EntryPoint', 
+ 
+    # Exceptions 
+    'ResolutionError', 'VersionConflict', 'DistributionNotFound', 
+    'UnknownExtra', 'ExtractionError', 
+ 
+    # Warnings 
+    'PEP440Warning', 
+ 
+    # Parsing functions and string utilities 
+    'parse_requirements', 'parse_version', 'safe_name', 'safe_version', 
+    'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections', 
+    'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker', 
+ 
+    # filesystem utilities 
+    'ensure_directory', 'normalize_path', 
+ 
+    # Distribution "precedence" constants 
+    'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST', 
+ 
+    # "Provider" interfaces, implementations, and registration/lookup APIs 
+    'IMetadataProvider', 'IResourceProvider', 'FileMetadata', 
+    'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider', 
+    'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider', 
+    'register_finder', 'register_namespace_handler', 'register_loader_type', 
+    'fixup_namespace_packages', 'get_importer', 
+ 
     # Warnings
     'PkgResourcesDeprecationWarning',
 
-    # Deprecated/backward compatibility only
-    'run_main', 'AvailableDistributions',
-]
-
+    # Deprecated/backward compatibility only 
+    'run_main', 'AvailableDistributions', 
+] 
+ 
 
-class ResolutionError(Exception):
-    """Abstract base for dependency resolution errors"""
+class ResolutionError(Exception): 
+    """Abstract base for dependency resolution errors""" 
 
-    def __repr__(self):
+    def __repr__(self): 
         return self.__class__.__name__ + repr(self.args)
-
-
-class VersionConflict(ResolutionError):
-    """
-    An already-installed version conflicts with the requested version.
-
-    Should be initialized with the installed Distribution and the requested
-    Requirement.
-    """
-
-    _template = "{self.dist} is installed but {self.req} is required"
-
-    @property
-    def dist(self):
-        return self.args[0]
-
-    @property
-    def req(self):
-        return self.args[1]
-
-    def report(self):
-        return self._template.format(**locals())
-
-    def with_context(self, required_by):
-        """
-        If required_by is non-empty, return a version of self that is a
-        ContextualVersionConflict.
-        """
-        if not required_by:
-            return self
-        args = self.args + (required_by,)
-        return ContextualVersionConflict(*args)
-
-
-class ContextualVersionConflict(VersionConflict):
-    """
-    A VersionConflict that accepts a third parameter, the set of the
-    requirements that required the installed Distribution.
-    """
-
-    _template = VersionConflict._template + ' by {self.required_by}'
-
-    @property
-    def required_by(self):
-        return self.args[2]
-
-
-class DistributionNotFound(ResolutionError):
-    """A requested distribution was not found"""
-
-    _template = ("The '{self.req}' distribution was not found "
-                 "and is required by {self.requirers_str}")
-
-    @property
-    def req(self):
-        return self.args[0]
-
-    @property
-    def requirers(self):
-        return self.args[1]
-
-    @property
-    def requirers_str(self):
-        if not self.requirers:
-            return 'the application'
-        return ', '.join(self.requirers)
-
-    def report(self):
-        return self._template.format(**locals())
-
-    def __str__(self):
-        return self.report()
-
-
-class UnknownExtra(ResolutionError):
-    """Distribution doesn't have an "extra feature" of the given name"""
-
-
-_provider_factories = {}
-
+ 
+ 
+class VersionConflict(ResolutionError): 
+    """ 
+    An already-installed version conflicts with the requested version. 
+ 
+    Should be initialized with the installed Distribution and the requested 
+    Requirement. 
+    """ 
+ 
+    _template = "{self.dist} is installed but {self.req} is required" 
+ 
+    @property 
+    def dist(self): 
+        return self.args[0] 
+ 
+    @property 
+    def req(self): 
+        return self.args[1] 
+ 
+    def report(self): 
+        return self._template.format(**locals()) 
+ 
+    def with_context(self, required_by): 
+        """ 
+        If required_by is non-empty, return a version of self that is a 
+        ContextualVersionConflict. 
+        """ 
+        if not required_by: 
+            return self 
+        args = self.args + (required_by,) 
+        return ContextualVersionConflict(*args) 
+ 
+ 
+class ContextualVersionConflict(VersionConflict): 
+    """ 
+    A VersionConflict that accepts a third parameter, the set of the 
+    requirements that required the installed Distribution. 
+    """ 
+ 
+    _template = VersionConflict._template + ' by {self.required_by}' 
+ 
+    @property 
+    def required_by(self): 
+        return self.args[2] 
+ 
+ 
+class DistributionNotFound(ResolutionError): 
+    """A requested distribution was not found""" 
+ 
+    _template = ("The '{self.req}' distribution was not found " 
+                 "and is required by {self.requirers_str}") 
+ 
+    @property 
+    def req(self): 
+        return self.args[0] 
+ 
+    @property 
+    def requirers(self): 
+        return self.args[1] 
+ 
+    @property 
+    def requirers_str(self): 
+        if not self.requirers: 
+            return 'the application' 
+        return ', '.join(self.requirers) 
+ 
+    def report(self): 
+        return self._template.format(**locals()) 
+ 
+    def __str__(self): 
+        return self.report() 
+ 
+ 
+class UnknownExtra(ResolutionError): 
+    """Distribution doesn't have an "extra feature" of the given name""" 
+
+
+_provider_factories = {} 
+ 
 PY_MAJOR = '{}.{}'.format(*sys.version_info)
-EGG_DIST = 3
-BINARY_DIST = 2
-SOURCE_DIST = 1
-CHECKOUT_DIST = 0
-DEVELOP_DIST = -1
-
-
-def register_loader_type(loader_type, provider_factory):
-    """Register `provider_factory` to make providers for `loader_type`
-
-    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,
-    and `provider_factory` is a function that, passed a *module* object,
-    returns an ``IResourceProvider`` for that module.
-    """
-    _provider_factories[loader_type] = provider_factory
-
-
-def get_provider(moduleOrReq):
-    """Return an IResourceProvider for the named module or requirement"""
-    if isinstance(moduleOrReq, Requirement):
-        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
-    try:
-        module = sys.modules[moduleOrReq]
-    except KeyError:
-        __import__(moduleOrReq)
-        module = sys.modules[moduleOrReq]
-    loader = getattr(module, '__loader__', None)
-    return _find_adapter(_provider_factories, loader)(module)
-
-
-def _macosx_vers(_cache=[]):
-    if not _cache:
-        version = platform.mac_ver()[0]
-        # fallback for MacPorts
-        if version == '':
-            plist = '/System/Library/CoreServices/SystemVersion.plist'
-            if os.path.exists(plist):
-                if hasattr(plistlib, 'readPlist'):
-                    plist_content = plistlib.readPlist(plist)
-                    if 'ProductVersion' in plist_content:
-                        version = plist_content['ProductVersion']
-
-        _cache.append(version.split('.'))
-    return _cache[0]
-
-
-def _macosx_arch(machine):
-    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
-
-
-def get_build_platform():
-    """Return this platform's string for platform-specific distributions
-
-    XXX Currently this is the same as ``distutils.util.get_platform()``, but it
-    needs some hacks for Linux and Mac OS X.
-    """
+EGG_DIST = 3 
+BINARY_DIST = 2 
+SOURCE_DIST = 1 
+CHECKOUT_DIST = 0 
+DEVELOP_DIST = -1 
+ 
+
+def register_loader_type(loader_type, provider_factory): 
+    """Register `provider_factory` to make providers for `loader_type` 
+ 
+    `loader_type` is the type or class of a PEP 302 ``module.__loader__``, 
+    and `provider_factory` is a function that, passed a *module* object, 
+    returns an ``IResourceProvider`` for that module. 
+    """ 
+    _provider_factories[loader_type] = provider_factory 
+ 
+
+def get_provider(moduleOrReq): 
+    """Return an IResourceProvider for the named module or requirement""" 
+    if isinstance(moduleOrReq, Requirement): 
+        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0] 
+    try: 
+        module = sys.modules[moduleOrReq] 
+    except KeyError: 
+        __import__(moduleOrReq) 
+        module = sys.modules[moduleOrReq] 
+    loader = getattr(module, '__loader__', None) 
+    return _find_adapter(_provider_factories, loader)(module) 
+ 
+
+def _macosx_vers(_cache=[]): 
+    if not _cache: 
+        version = platform.mac_ver()[0] 
+        # fallback for MacPorts 
+        if version == '': 
+            plist = '/System/Library/CoreServices/SystemVersion.plist' 
+            if os.path.exists(plist): 
+                if hasattr(plistlib, 'readPlist'): 
+                    plist_content = plistlib.readPlist(plist) 
+                    if 'ProductVersion' in plist_content: 
+                        version = plist_content['ProductVersion'] 
+ 
+        _cache.append(version.split('.')) 
+    return _cache[0] 
+ 
+
+def _macosx_arch(machine): 
+    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine) 
+ 
+
+def get_build_platform(): 
+    """Return this platform's string for platform-specific distributions 
+ 
+    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
-
-    plat = get_platform()
-    if sys.platform == "darwin" and not plat.startswith('macosx-'):
-        try:
-            version = _macosx_vers()
-            machine = os.uname()[4].replace(" ", "_")
+ 
+    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),
             )
-        except ValueError:
-            # if someone is running a non-Mac darwin system, this will fall
-            # through to the default implementation
-            pass
-    return plat
-
-
-macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")
-darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
-# XXX backward compat
-get_platform = get_build_platform
-
-
-def compatible_platforms(provided, required):
-    """Can code for the `provided` platform run on the `required` platform?
-
-    Returns true if either platform is ``None``, or the platforms are equal.
-
-    XXX Needs compatibility checks for Linux and other unixy OSes.
-    """
+        except ValueError: 
+            # if someone is running a non-Mac darwin system, this will fall 
+            # through to the default implementation 
+            pass 
+    return plat 
+ 
+
+macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)") 
+darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)") 
+# XXX backward compat 
+get_platform = get_build_platform 
+ 
+ 
+def compatible_platforms(provided, required): 
+    """Can code for the `provided` platform run on the `required` platform? 
+ 
+    Returns true if either platform is ``None``, or the platforms are equal. 
+ 
+    XXX Needs compatibility checks for Linux and other unixy OSes. 
+    """ 
     if provided is None or required is None or provided == required:
-        # easy case
-        return True
-
-    # Mac OS X special cases
-    reqMac = macosVersionString.match(required)
-    if reqMac:
-        provMac = macosVersionString.match(provided)
-
-        # is this a Mac package?
-        if not provMac:
-            # this is backwards compatibility for packages built before
-            # setuptools 0.6. All packages built after this point will
-            # use the new macosx designation.
-            provDarwin = darwinVersionString.match(provided)
-            if provDarwin:
-                dversion = int(provDarwin.group(1))
-                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
-                if dversion == 7 and macosversion >= "10.3" or \
-                        dversion == 8 and macosversion >= "10.4":
-                    return True
-            # egg isn't macosx or legacy darwin
-            return False
-
-        # are they the same major version and machine type?
-        if provMac.group(1) != reqMac.group(1) or \
-                provMac.group(3) != reqMac.group(3):
-            return False
-
-        # is the required OS major update >= the provided one?
-        if int(provMac.group(2)) > int(reqMac.group(2)):
-            return False
-
-        return True
-
-    # XXX Linux and other platforms' special cases should go here
-    return False
-
-
-def run_script(dist_spec, script_name):
-    """Locate distribution `dist_spec` and run its `script_name` script"""
-    ns = sys._getframe(1).f_globals
-    name = ns['__name__']
-    ns.clear()
-    ns['__name__'] = name
-    require(dist_spec)[0].run_script(script_name, ns)
-
-
-# backward compatibility
-run_main = run_script
-
-
-def get_distribution(dist):
-    """Return a current distribution object for a Requirement or string"""
-    if isinstance(dist, six.string_types):
-        dist = Requirement.parse(dist)
-    if isinstance(dist, Requirement):
-        dist = get_provider(dist)
-    if not isinstance(dist, Distribution):
-        raise TypeError("Expected string, Requirement, or Distribution", dist)
-    return dist
-
-
-def load_entry_point(dist, group, name):
-    """Return `name` entry point of `group` for `dist` or raise ImportError"""
-    return get_distribution(dist).load_entry_point(group, name)
-
-
-def get_entry_map(dist, group=None):
-    """Return the entry point map for `group`, or the full entry map"""
-    return get_distribution(dist).get_entry_map(group)
-
-
-def get_entry_info(dist, group, name):
-    """Return the EntryPoint object for `group`+`name`, or ``None``"""
-    return get_distribution(dist).get_entry_info(group, name)
-
-
-class IMetadataProvider:
-    def has_metadata(name):
-        """Does the package's distribution contain the named metadata?"""
-
-    def get_metadata(name):
-        """The named metadata resource as a string"""
-
-    def get_metadata_lines(name):
-        """Yield named metadata resource as list of non-blank non-comment lines
-
-       Leading and trailing whitespace is stripped from each line, and lines
-       with ``#`` as the first non-blank character are omitted."""
-
-    def metadata_isdir(name):
-        """Is the named metadata a directory?  (like ``os.path.isdir()``)"""
-
-    def metadata_listdir(name):
-        """List of metadata names in the directory (like ``os.listdir()``)"""
-
-    def run_script(script_name, namespace):
-        """Execute the named script in the supplied namespace dictionary"""
-
-
-class IResourceProvider(IMetadataProvider):
-    """An object that provides access to package resources"""
-
-    def get_resource_filename(manager, resource_name):
-        """Return a true filesystem path for `resource_name`
-
-        `manager` must be an ``IResourceManager``"""
-
-    def get_resource_stream(manager, resource_name):
-        """Return a readable file-like object for `resource_name`
-
-        `manager` must be an ``IResourceManager``"""
-
-    def get_resource_string(manager, resource_name):
-        """Return a string containing the contents of `resource_name`
-
-        `manager` must be an ``IResourceManager``"""
-
-    def has_resource(resource_name):
-        """Does the package contain the named resource?"""
-
-    def resource_isdir(resource_name):
-        """Is the named resource a directory?  (like ``os.path.isdir()``)"""
-
-    def resource_listdir(resource_name):
-        """List of resource names in the directory (like ``os.listdir()``)"""
-
-
+        # easy case 
+        return True 
+ 
+    # Mac OS X special cases 
+    reqMac = macosVersionString.match(required) 
+    if reqMac: 
+        provMac = macosVersionString.match(provided) 
+ 
+        # is this a Mac package? 
+        if not provMac: 
+            # this is backwards compatibility for packages built before 
+            # setuptools 0.6. All packages built after this point will 
+            # use the new macosx designation. 
+            provDarwin = darwinVersionString.match(provided) 
+            if provDarwin: 
+                dversion = int(provDarwin.group(1)) 
+                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2)) 
+                if dversion == 7 and macosversion >= "10.3" or \ 
+                        dversion == 8 and macosversion >= "10.4": 
+                    return True 
+            # egg isn't macosx or legacy darwin 
+            return False 
+ 
+        # are they the same major version and machine type? 
+        if provMac.group(1) != reqMac.group(1) or \ 
+                provMac.group(3) != reqMac.group(3): 
+            return False 
+ 
+        # is the required OS major update >= the provided one? 
+        if int(provMac.group(2)) > int(reqMac.group(2)): 
+            return False 
+ 
+        return True 
+ 
+    # XXX Linux and other platforms' special cases should go here 
+    return False 
+ 
+ 
+def run_script(dist_spec, script_name): 
+    """Locate distribution `dist_spec` and run its `script_name` script""" 
+    ns = sys._getframe(1).f_globals 
+    name = ns['__name__'] 
+    ns.clear() 
+    ns['__name__'] = name 
+    require(dist_spec)[0].run_script(script_name, ns) 
+ 
+
+# backward compatibility 
+run_main = run_script 
+ 
+
+def get_distribution(dist): 
+    """Return a current distribution object for a Requirement or string""" 
+    if isinstance(dist, six.string_types): 
+        dist = Requirement.parse(dist) 
+    if isinstance(dist, Requirement): 
+        dist = get_provider(dist) 
+    if not isinstance(dist, Distribution): 
+        raise TypeError("Expected string, Requirement, or Distribution", dist) 
+    return dist 
+ 
+
+def load_entry_point(dist, group, name): 
+    """Return `name` entry point of `group` for `dist` or raise ImportError""" 
+    return get_distribution(dist).load_entry_point(group, name) 
+ 
+
+def get_entry_map(dist, group=None): 
+    """Return the entry point map for `group`, or the full entry map""" 
+    return get_distribution(dist).get_entry_map(group) 
+ 
+
+def get_entry_info(dist, group, name): 
+    """Return the EntryPoint object for `group`+`name`, or ``None``""" 
+    return get_distribution(dist).get_entry_info(group, name) 
+ 
+ 
+class IMetadataProvider: 
+    def has_metadata(name): 
+        """Does the package's distribution contain the named metadata?""" 
+ 
+    def get_metadata(name): 
+        """The named metadata resource as a string""" 
+ 
+    def get_metadata_lines(name): 
+        """Yield named metadata resource as list of non-blank non-comment lines 
+ 
+       Leading and trailing whitespace is stripped from each line, and lines 
+       with ``#`` as the first non-blank character are omitted.""" 
+ 
+    def metadata_isdir(name): 
+        """Is the named metadata a directory?  (like ``os.path.isdir()``)""" 
+ 
+    def metadata_listdir(name): 
+        """List of metadata names in the directory (like ``os.listdir()``)""" 
+ 
+    def run_script(script_name, namespace): 
+        """Execute the named script in the supplied namespace dictionary""" 
+ 
+ 
+class IResourceProvider(IMetadataProvider): 
+    """An object that provides access to package resources""" 
+ 
+    def get_resource_filename(manager, resource_name): 
+        """Return a true filesystem path for `resource_name` 
+ 
+        `manager` must be an ``IResourceManager``""" 
+ 
+    def get_resource_stream(manager, resource_name): 
+        """Return a readable file-like object for `resource_name` 
+ 
+        `manager` must be an ``IResourceManager``""" 
+ 
+    def get_resource_string(manager, resource_name): 
+        """Return a string containing the contents of `resource_name` 
+ 
+        `manager` must be an ``IResourceManager``""" 
+ 
+    def has_resource(resource_name): 
+        """Does the package contain the named resource?""" 
+ 
+    def resource_isdir(resource_name): 
+        """Is the named resource a directory?  (like ``os.path.isdir()``)""" 
+ 
+    def resource_listdir(resource_name): 
+        """List of resource names in the directory (like ``os.listdir()``)""" 
+ 
+ 
 class WorkingSet:
-    """A collection of active distributions on sys.path (or a similar list)"""
-
-    def __init__(self, entries=None):
-        """Create working set from list of path entries (default=sys.path)"""
-        self.entries = []
-        self.entry_keys = {}
-        self.by_key = {}
-        self.callbacks = []
-
-        if entries is None:
-            entries = sys.path
-
-        for entry in entries:
-            self.add_entry(entry)
-
-    @classmethod
-    def _build_master(cls):
-        """
-        Prepare the master working set.
-        """
-        ws = cls()
-        try:
-            from __main__ import __requires__
-        except ImportError:
-            # The main program does not list any requirements
-            return ws
-
-        # ensure the requirements are met
-        try:
-            ws.require(__requires__)
-        except VersionConflict:
-            return cls._build_from_requirements(__requires__)
-
-        return ws
-
-    @classmethod
-    def _build_from_requirements(cls, req_spec):
-        """
-        Build a working set from a requirement spec. Rewrites sys.path.
-        """
-        # try it without defaults already on sys.path
-        # by starting with an empty path
-        ws = cls([])
-        reqs = parse_requirements(req_spec)
-        dists = ws.resolve(reqs, Environment())
-        for dist in dists:
-            ws.add(dist)
-
-        # add any missing entries from sys.path
-        for entry in sys.path:
-            if entry not in ws.entries:
-                ws.add_entry(entry)
-
-        # then copy back to sys.path
-        sys.path[:] = ws.entries
-        return ws
-
-    def add_entry(self, entry):
-        """Add a path item to ``.entries``, finding any distributions on it
-
-        ``find_distributions(entry, True)`` is used to find distributions
-        corresponding to the path entry, and they are added.  `entry` is
-        always appended to ``.entries``, even if it is already present.
-        (This is because ``sys.path`` can contain the same value more than
-        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
-        equal ``sys.path``.)
-        """
-        self.entry_keys.setdefault(entry, [])
-        self.entries.append(entry)
-        for dist in find_distributions(entry, True):
-            self.add(dist, entry, False)
-
-    def __contains__(self, dist):
-        """True if `dist` is the active distribution for its project"""
-        return self.by_key.get(dist.key) == dist
-
-    def find(self, req):
-        """Find a distribution matching requirement `req`
-
-        If there is an active distribution for the requested project, this
-        returns it as long as it meets the version requirement specified by
-        `req`.  But, if there is an active distribution for the project and it
-        does *not* meet the `req` requirement, ``VersionConflict`` is raised.
-        If there is no active distribution for the requested project, ``None``
-        is returned.
-        """
-        dist = self.by_key.get(req.key)
-        if dist is not None and dist not in req:
-            # XXX add more info
-            raise VersionConflict(dist, req)
-        return dist
-
-    def iter_entry_points(self, group, name=None):
-        """Yield entry point objects from `group` matching `name`
-
-        If `name` is None, yields all entry points in `group` from all
-        distributions in the working set, otherwise only ones matching
-        both `group` and `name` are yielded (in distribution order).
-        """
+    """A collection of active distributions on sys.path (or a similar list)""" 
+ 
+    def __init__(self, entries=None): 
+        """Create working set from list of path entries (default=sys.path)""" 
+        self.entries = [] 
+        self.entry_keys = {} 
+        self.by_key = {} 
+        self.callbacks = [] 
+ 
+        if entries is None: 
+            entries = sys.path 
+ 
+        for entry in entries: 
+            self.add_entry(entry) 
+ 
+    @classmethod 
+    def _build_master(cls): 
+        """ 
+        Prepare the master working set. 
+        """ 
+        ws = cls() 
+        try: 
+            from __main__ import __requires__ 
+        except ImportError: 
+            # The main program does not list any requirements 
+            return ws 
+ 
+        # ensure the requirements are met 
+        try: 
+            ws.require(__requires__) 
+        except VersionConflict: 
+            return cls._build_from_requirements(__requires__) 
+ 
+        return ws 
+ 
+    @classmethod 
+    def _build_from_requirements(cls, req_spec): 
+        """ 
+        Build a working set from a requirement spec. Rewrites sys.path. 
+        """ 
+        # try it without defaults already on sys.path 
+        # by starting with an empty path 
+        ws = cls([]) 
+        reqs = parse_requirements(req_spec) 
+        dists = ws.resolve(reqs, Environment()) 
+        for dist in dists: 
+            ws.add(dist) 
+ 
+        # add any missing entries from sys.path 
+        for entry in sys.path: 
+            if entry not in ws.entries: 
+                ws.add_entry(entry) 
+ 
+        # then copy back to sys.path 
+        sys.path[:] = ws.entries 
+        return ws 
+ 
+    def add_entry(self, entry): 
+        """Add a path item to ``.entries``, finding any distributions on it 
+ 
+        ``find_distributions(entry, True)`` is used to find distributions 
+        corresponding to the path entry, and they are added.  `entry` is 
+        always appended to ``.entries``, even if it is already present. 
+        (This is because ``sys.path`` can contain the same value more than 
+        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always 
+        equal ``sys.path``.) 
+        """ 
+        self.entry_keys.setdefault(entry, []) 
+        self.entries.append(entry) 
+        for dist in find_distributions(entry, True): 
+            self.add(dist, entry, False) 
+ 
+    def __contains__(self, dist): 
+        """True if `dist` is the active distribution for its project""" 
+        return self.by_key.get(dist.key) == dist 
+ 
+    def find(self, req): 
+        """Find a distribution matching requirement `req` 
+ 
+        If there is an active distribution for the requested project, this 
+        returns it as long as it meets the version requirement specified by 
+        `req`.  But, if there is an active distribution for the project and it 
+        does *not* meet the `req` requirement, ``VersionConflict`` is raised. 
+        If there is no active distribution for the requested project, ``None`` 
+        is returned. 
+        """ 
+        dist = self.by_key.get(req.key) 
+        if dist is not None and dist not in req: 
+            # XXX add more info 
+            raise VersionConflict(dist, req) 
+        return dist 
+ 
+    def iter_entry_points(self, group, name=None): 
+        """Yield entry point objects from `group` matching `name` 
+ 
+        If `name` is None, yields all entry points in `group` from all 
+        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
         )
-
-    def run_script(self, requires, script_name):
-        """Locate distribution for `requires` and run `script_name` script"""
-        ns = sys._getframe(1).f_globals
-        name = ns['__name__']
-        ns.clear()
-        ns['__name__'] = name
-        self.require(requires)[0].run_script(script_name, ns)
-
-    def __iter__(self):
-        """Yield distributions for non-duplicate projects in the working set
-
-        The yield order is the order in which the items' path entries were
-        added to the working set.
-        """
-        seen = {}
-        for item in self.entries:
-            if item not in self.entry_keys:
-                # workaround a cache issue
-                continue
-
-            for key in self.entry_keys[item]:
-                if key not in seen:
+ 
+    def run_script(self, requires, script_name): 
+        """Locate distribution for `requires` and run `script_name` script""" 
+        ns = sys._getframe(1).f_globals 
+        name = ns['__name__'] 
+        ns.clear() 
+        ns['__name__'] = name 
+        self.require(requires)[0].run_script(script_name, ns) 
+ 
+    def __iter__(self): 
+        """Yield distributions for non-duplicate projects in the working set 
+ 
+        The yield order is the order in which the items' path entries were 
+        added to the working set. 
+        """ 
+        seen = {} 
+        for item in self.entries: 
+            if item not in self.entry_keys: 
+                # workaround a cache issue 
+                continue 
+ 
+            for key in self.entry_keys[item]: 
+                if key not in seen: 
                     seen[key] = 1
-                    yield self.by_key[key]
-
-    def add(self, dist, entry=None, insert=True, replace=False):
-        """Add `dist` to working set, associated with `entry`
-
-        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
-        On exit from this routine, `entry` is added to the end of the working
-        set's ``.entries`` (if it wasn't already present).
-
-        `dist` is only added to the working set if it's for a project that
-        doesn't already have a distribution in the set, unless `replace=True`.
-        If it's added, any callbacks registered with the ``subscribe()`` method
-        will be called.
-        """
-        if insert:
-            dist.insert_on(self.entries, entry, replace=replace)
-
-        if entry is None:
-            entry = dist.location
+                    yield self.by_key[key] 
+ 
+    def add(self, dist, entry=None, insert=True, replace=False): 
+        """Add `dist` to working set, associated with `entry` 
+ 
+        If `entry` is unspecified, it defaults to the ``.location`` of `dist`. 
+        On exit from this routine, `entry` is added to the end of the working 
+        set's ``.entries`` (if it wasn't already present). 
+ 
+        `dist` is only added to the working set if it's for a project that 
+        doesn't already have a distribution in the set, unless `replace=True`. 
+        If it's added, any callbacks registered with the ``subscribe()`` method 
+        will be called. 
+        """ 
+        if insert: 
+            dist.insert_on(self.entries, entry, replace=replace) 
+ 
+        if entry is None: 
+            entry = dist.location 
         keys = self.entry_keys.setdefault(entry, [])
         keys2 = self.entry_keys.setdefault(dist.location, [])
-        if not replace and dist.key in self.by_key:
-            # ignore hidden distros
-            return
-
-        self.by_key[dist.key] = dist
-        if dist.key not in keys:
-            keys.append(dist.key)
-        if dist.key not in keys2:
-            keys2.append(dist.key)
-        self._added_new(dist)
-
-    def resolve(self, requirements, env=None, installer=None,
+        if not replace and dist.key in self.by_key: 
+            # ignore hidden distros 
+            return 
+ 
+        self.by_key[dist.key] = dist 
+        if dist.key not in keys: 
+            keys.append(dist.key) 
+        if dist.key not in keys2: 
+            keys2.append(dist.key) 
+        self._added_new(dist) 
+ 
+    def resolve(self, requirements, env=None, installer=None, 
                 replace_conflicting=False, extras=None):
-        """List all distributions needed to (recursively) meet `requirements`
-
-        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
-        if supplied, should be an ``Environment`` instance.  If
-        not supplied, it defaults to all distributions available within any
-        entry or distribution in the working set.  `installer`, if supplied,
-        will be invoked with each requirement that cannot be met by an
-        already-installed distribution; it should return a ``Distribution`` or
-        ``None``.
-
+        """List all distributions needed to (recursively) meet `requirements` 
+ 
+        `requirements` must be a sequence of ``Requirement`` objects.  `env`, 
+        if supplied, should be an ``Environment`` instance.  If 
+        not supplied, it defaults to all distributions available within any 
+        entry or distribution in the working set.  `installer`, if supplied, 
+        will be invoked with each requirement that cannot be met by an 
+        already-installed distribution; it should return a ``Distribution`` or 
+        ``None``. 
+ 
         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
-        it.
+        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 
+        it. 
 
         `extras` is a list of the extras to be used with these requirements.
         This is important because extra requirements may look like `my_req;
         extra = "my_extra"`, which would otherwise be interpreted as a purely
         optional requirement.  Instead, we want to be able to assert that these
         requirements are truly required.
-        """
-
-        # set up the stack
-        requirements = list(requirements)[::-1]
-        # set of processed requirements
-        processed = {}
-        # key -> dist
-        best = {}
-        to_activate = []
-
+        """ 
+ 
+        # set up the stack 
+        requirements = list(requirements)[::-1] 
+        # set of processed requirements 
+        processed = {} 
+        # key -> dist 
+        best = {} 
+        to_activate = [] 
+ 
         req_extras = _ReqExtras()
 
-        # Mapping of requirement to set of distributions that required it;
-        # useful for reporting info about conflicts.
-        required_by = collections.defaultdict(set)
-
-        while requirements:
-            # process dependencies breadth-first
-            req = requirements.pop(0)
-            if req in processed:
-                # Ignore cyclic or redundant dependencies
-                continue
+        # Mapping of requirement to set of distributions that required it; 
+        # useful for reporting info about conflicts. 
+        required_by = collections.defaultdict(set) 
+ 
+        while requirements: 
+            # process dependencies breadth-first 
+            req = requirements.pop(0) 
+            if req in processed: 
+                # Ignore cyclic or redundant dependencies 
+                continue 
 
             if not req_extras.markers_pass(req, extras):
                 continue
 
-            dist = best.get(req.key)
-            if dist is None:
-                # Find the best distribution and add it to the map
-                dist = self.by_key.get(req.key)
-                if dist is None or (dist not in req and replace_conflicting):
-                    ws = self
-                    if env is None:
-                        if dist is None:
-                            env = Environment(self.entries)
-                        else:
-                            # Use an empty environment and workingset to avoid
-                            # any further conflicts with the conflicting
-                            # distribution
-                            env = Environment([])
-                            ws = WorkingSet([])
+            dist = best.get(req.key) 
+            if dist is None: 
+                # Find the best distribution and add it to the map 
+                dist = self.by_key.get(req.key) 
+                if dist is None or (dist not in req and replace_conflicting): 
+                    ws = self 
+                    if env is None: 
+                        if dist is None: 
+                            env = Environment(self.entries) 
+                        else: 
+                            # Use an empty environment and workingset to avoid 
+                            # any further conflicts with the conflicting 
+                            # distribution 
+                            env = Environment([]) 
+                            ws = WorkingSet([]) 
                     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)
-                to_activate.append(dist)
-            if dist not in req:
-                # Oops, the "best" so far conflicts with a dependency
-                dependent_req = required_by[req]
-                raise VersionConflict(dist, req).with_context(dependent_req)
-
-            # push the new requirements onto the stack
-            new_requirements = dist.requires(req.extras)[::-1]
-            requirements.extend(new_requirements)
-
-            # Register the new requirements needed by req
-            for new_requirement in new_requirements:
-                required_by[new_requirement].add(req.project_name)
+                    if dist is None: 
+                        requirers = required_by.get(req, None) 
+                        raise DistributionNotFound(req, requirers) 
+                to_activate.append(dist) 
+            if dist not in req: 
+                # Oops, the "best" so far conflicts with a dependency 
+                dependent_req = required_by[req] 
+                raise VersionConflict(dist, req).with_context(dependent_req) 
+ 
+            # push the new requirements onto the stack 
+            new_requirements = dist.requires(req.extras)[::-1] 
+            requirements.extend(new_requirements) 
+ 
+            # Register the new requirements needed by req 
+            for new_requirement in new_requirements: 
+                required_by[new_requirement].add(req.project_name) 
                 req_extras[new_requirement] = req.extras
-
-            processed[req] = True
-
-        # return list of distros to activate
-        return to_activate
-
+ 
+            processed[req] = True 
+ 
+        # return list of distros to activate 
+        return to_activate 
+ 
     def find_plugins(
             self, plugin_env, full_env=None, installer=None, fallback=True):
-        """Find all activatable distributions in `plugin_env`
-
-        Example usage::
-
-            distributions, errors = working_set.find_plugins(
-                Environment(plugin_dirlist)
-            )
-            # add plugins+libs to sys.path
-            map(working_set.add, distributions)
-            # display errors
-            print('Could not load', errors)
-
-        The `plugin_env` should be an ``Environment`` instance that contains
-        only distributions that are in the project's "plugin directory" or
-        directories. The `full_env`, if supplied, should be an ``Environment``
-        contains all currently-available distributions.  If `full_env` is not
-        supplied, one is created automatically from the ``WorkingSet`` this
-        method is called on, which will typically mean that every directory on
-        ``sys.path`` will be scanned for distributions.
-
-        `installer` is a standard installer callback as used by the
-        ``resolve()`` method. The `fallback` flag indicates whether we should
-        attempt to resolve older versions of a plugin if the newest version
-        cannot be resolved.
-
-        This method returns a 2-tuple: (`distributions`, `error_info`), where
-        `distributions` is a list of the distributions found in `plugin_env`
-        that were loadable, along with any other distributions that are needed
-        to resolve their dependencies.  `error_info` is a dictionary mapping
-        unloadable plugin distributions to an exception instance describing the
-        error that occurred. Usually this will be a ``DistributionNotFound`` or
-        ``VersionConflict`` instance.
-        """
-
-        plugin_projects = list(plugin_env)
-        # scan project names in alphabetic order
-        plugin_projects.sort()
-
-        error_info = {}
-        distributions = {}
-
-        if full_env is None:
-            env = Environment(self.entries)
-            env += plugin_env
-        else:
-            env = full_env + plugin_env
-
-        shadow_set = self.__class__([])
-        # put all our entries in shadow_set
-        list(map(shadow_set.add, self))
-
-        for project_name in plugin_projects:
-
-            for dist in plugin_env[project_name]:
-
-                req = [dist.as_requirement()]
-
-                try:
-                    resolvees = shadow_set.resolve(req, env, installer)
-
-                except ResolutionError as v:
-                    # save error info
-                    error_info[dist] = v
-                    if fallback:
-                        # try the next older version of project
-                        continue
-                    else:
-                        # give up on this project, keep going
-                        break
-
-                else:
-                    list(map(shadow_set.add, resolvees))
-                    distributions.update(dict.fromkeys(resolvees))
-
-                    # success, no need to try any more versions of this project
-                    break
-
-        distributions = list(distributions)
-        distributions.sort()
-
-        return distributions, error_info
-
-    def require(self, *requirements):
-        """Ensure that distributions matching `requirements` are activated
-
-        `requirements` must be a string or a (possibly-nested) sequence
-        thereof, specifying the distributions and versions required.  The
-        return value is a sequence of the distributions that needed to be
-        activated to fulfill the requirements; all relevant distributions are
-        included, even if they were already activated in this working set.
-        """
-        needed = self.resolve(parse_requirements(requirements))
-
-        for dist in needed:
-            self.add(dist)
-
-        return needed
-
+        """Find all activatable distributions in `plugin_env` 
+ 
+        Example usage:: 
+ 
+            distributions, errors = working_set.find_plugins( 
+                Environment(plugin_dirlist) 
+            ) 
+            # add plugins+libs to sys.path 
+            map(working_set.add, distributions) 
+            # display errors 
+            print('Could not load', errors) 
+ 
+        The `plugin_env` should be an ``Environment`` instance that contains 
+        only distributions that are in the project's "plugin directory" or 
+        directories. The `full_env`, if supplied, should be an ``Environment`` 
+        contains all currently-available distributions.  If `full_env` is not 
+        supplied, one is created automatically from the ``WorkingSet`` this 
+        method is called on, which will typically mean that every directory on 
+        ``sys.path`` will be scanned for distributions. 
+ 
+        `installer` is a standard installer callback as used by the 
+        ``resolve()`` method. The `fallback` flag indicates whether we should 
+        attempt to resolve older versions of a plugin if the newest version 
+        cannot be resolved. 
+ 
+        This method returns a 2-tuple: (`distributions`, `error_info`), where 
+        `distributions` is a list of the distributions found in `plugin_env` 
+        that were loadable, along with any other distributions that are needed 
+        to resolve their dependencies.  `error_info` is a dictionary mapping 
+        unloadable plugin distributions to an exception instance describing the 
+        error that occurred. Usually this will be a ``DistributionNotFound`` or 
+        ``VersionConflict`` instance. 
+        """ 
+ 
+        plugin_projects = list(plugin_env) 
+        # scan project names in alphabetic order 
+        plugin_projects.sort() 
+ 
+        error_info = {} 
+        distributions = {} 
+ 
+        if full_env is None: 
+            env = Environment(self.entries) 
+            env += plugin_env 
+        else: 
+            env = full_env + plugin_env 
+ 
+        shadow_set = self.__class__([]) 
+        # put all our entries in shadow_set 
+        list(map(shadow_set.add, self)) 
+ 
+        for project_name in plugin_projects: 
+ 
+            for dist in plugin_env[project_name]: 
+ 
+                req = [dist.as_requirement()] 
+ 
+                try: 
+                    resolvees = shadow_set.resolve(req, env, installer) 
+ 
+                except ResolutionError as v: 
+                    # save error info 
+                    error_info[dist] = v 
+                    if fallback: 
+                        # try the next older version of project 
+                        continue 
+                    else: 
+                        # give up on this project, keep going 
+                        break 
+ 
+                else: 
+                    list(map(shadow_set.add, resolvees)) 
+                    distributions.update(dict.fromkeys(resolvees)) 
+ 
+                    # success, no need to try any more versions of this project 
+                    break 
+ 
+        distributions = list(distributions) 
+        distributions.sort() 
+ 
+        return distributions, error_info 
+ 
+    def require(self, *requirements): 
+        """Ensure that distributions matching `requirements` are activated 
+ 
+        `requirements` must be a string or a (possibly-nested) sequence 
+        thereof, specifying the distributions and versions required.  The 
+        return value is a sequence of the distributions that needed to be 
+        activated to fulfill the requirements; all relevant distributions are 
+        included, even if they were already activated in this working set. 
+        """ 
+        needed = self.resolve(parse_requirements(requirements)) 
+ 
+        for dist in needed: 
+            self.add(dist) 
+ 
+        return needed 
+ 
     def subscribe(self, callback, existing=True):
         """Invoke `callback` for all distributions
 
         If `existing=True` (default),
         call on all existing ones, as well.
         """
-        if callback in self.callbacks:
-            return
-        self.callbacks.append(callback)
+        if callback in self.callbacks: 
+            return 
+        self.callbacks.append(callback) 
         if not existing:
             return
-        for dist in self:
-            callback(dist)
-
-    def _added_new(self, dist):
-        for callback in self.callbacks:
-            callback(dist)
-
-    def __getstate__(self):
-        return (
-            self.entries[:], self.entry_keys.copy(), self.by_key.copy(),
-            self.callbacks[:]
-        )
-
-    def __setstate__(self, e_k_b_c):
-        entries, keys, by_key, callbacks = e_k_b_c
-        self.entries = entries[:]
-        self.entry_keys = keys.copy()
-        self.by_key = by_key.copy()
-        self.callbacks = callbacks[:]
-
-
+        for dist in self: 
+            callback(dist) 
+ 
+    def _added_new(self, dist): 
+        for callback in self.callbacks: 
+            callback(dist) 
+ 
+    def __getstate__(self): 
+        return ( 
+            self.entries[:], self.entry_keys.copy(), self.by_key.copy(), 
+            self.callbacks[:] 
+        ) 
+ 
+    def __setstate__(self, e_k_b_c): 
+        entries, keys, by_key, callbacks = e_k_b_c 
+        self.entries = entries[:] 
+        self.entry_keys = keys.copy() 
+        self.by_key = by_key.copy() 
+        self.callbacks = callbacks[:] 
+ 
+ 
 class _ReqExtras(dict):
     """
     Map each requirement to the extras that demanded it.
@@ -957,353 +957,353 @@ class _ReqExtras(dict):
 
 
 class Environment:
-    """Searchable snapshot of distributions on a search path"""
-
+    """Searchable snapshot of distributions on a search path""" 
+ 
     def __init__(
             self, search_path=None, platform=get_supported_platform(),
-            python=PY_MAJOR):
-        """Snapshot distributions available on a search path
-
-        Any distributions found on `search_path` are added to the environment.
-        `search_path` should be a sequence of ``sys.path`` items.  If not
-        supplied, ``sys.path`` is used.
-
-        `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
+            python=PY_MAJOR): 
+        """Snapshot distributions available on a search path 
+ 
+        Any distributions found on `search_path` are added to the environment. 
+        `search_path` should be a sequence of ``sys.path`` items.  If not 
+        supplied, ``sys.path`` is used. 
+ 
+        `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'``);
-        it defaults to the current version.
-
-        You may explicitly set `platform` (and/or `python`) to ``None`` if you
-        wish to map *all* distributions, not just those compatible with the
-        running platform or Python version.
-        """
-        self._distmap = {}
-        self.platform = platform
-        self.python = python
-        self.scan(search_path)
-
-    def can_add(self, dist):
-        """Is distribution `dist` acceptable for this environment?
-
-        The distribution must match the platform and python version
-        requirements specified when this environment was created, or False
-        is returned.
-        """
+        it defaults to the current version. 
+ 
+        You may explicitly set `platform` (and/or `python`) to ``None`` if you 
+        wish to map *all* distributions, not just those compatible with the 
+        running platform or Python version. 
+        """ 
+        self._distmap = {} 
+        self.platform = platform 
+        self.python = python 
+        self.scan(search_path) 
+ 
+    def can_add(self, dist): 
+        """Is distribution `dist` acceptable for this environment? 
+ 
+        The distribution must match the platform and python version 
+        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)
-
-    def remove(self, dist):
-        """Remove `dist` from the environment"""
-        self._distmap[dist.key].remove(dist)
-
-    def scan(self, search_path=None):
-        """Scan `search_path` for distributions usable in this environment
-
-        Any distributions found are added to the environment.
-        `search_path` should be a sequence of ``sys.path`` items.  If not
-        supplied, ``sys.path`` is used.  Only distributions conforming to
-        the platform/python version defined at initialization are added.
-        """
-        if search_path is None:
-            search_path = sys.path
-
-        for item in search_path:
-            for dist in find_distributions(item):
-                self.add(dist)
-
-    def __getitem__(self, project_name):
-        """Return a newest-to-oldest list of distributions for `project_name`
-
-        Uses case-insensitive `project_name` comparison, assuming all the
-        project's distributions use their project's name converted to all
-        lowercase as their key.
-
-        """
-        distribution_key = project_name.lower()
-        return self._distmap.get(distribution_key, [])
-
-    def add(self, dist):
-        """Add `dist` if we ``can_add()`` it and it has not already been added
-        """
-        if self.can_add(dist) and dist.has_version():
-            dists = self._distmap.setdefault(dist.key, [])
-            if dist not in dists:
-                dists.append(dist)
-                dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
-
+ 
+    def remove(self, dist): 
+        """Remove `dist` from the environment""" 
+        self._distmap[dist.key].remove(dist) 
+ 
+    def scan(self, search_path=None): 
+        """Scan `search_path` for distributions usable in this environment 
+ 
+        Any distributions found are added to the environment. 
+        `search_path` should be a sequence of ``sys.path`` items.  If not 
+        supplied, ``sys.path`` is used.  Only distributions conforming to 
+        the platform/python version defined at initialization are added. 
+        """ 
+        if search_path is None: 
+            search_path = sys.path 
+ 
+        for item in search_path: 
+            for dist in find_distributions(item): 
+                self.add(dist) 
+ 
+    def __getitem__(self, project_name): 
+        """Return a newest-to-oldest list of distributions for `project_name` 
+ 
+        Uses case-insensitive `project_name` comparison, assuming all the 
+        project's distributions use their project's name converted to all 
+        lowercase as their key. 
+ 
+        """ 
+        distribution_key = project_name.lower() 
+        return self._distmap.get(distribution_key, []) 
+ 
+    def add(self, dist): 
+        """Add `dist` if we ``can_add()`` it and it has not already been added 
+        """ 
+        if self.can_add(dist) and dist.has_version(): 
+            dists = self._distmap.setdefault(dist.key, []) 
+            if dist not in dists: 
+                dists.append(dist) 
+                dists.sort(key=operator.attrgetter('hashcmp'), reverse=True) 
+ 
     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
-        suitable distribution is already active.  (This may raise
-        ``VersionConflict`` if an unsuitable version of the project is already
-        active in the specified `working_set`.)  If a suitable distribution
-        isn't active, this method returns the newest distribution in the
-        environment that meets the ``Requirement`` in `req`.  If no suitable
-        distribution is found, and `installer` is supplied, then the result of
-        calling the environment's ``obtain(req, installer)`` method will be
-        returned.
-        """
+        """Find distribution best matching `req` and usable on `working_set` 
+ 
+        This calls the ``find(req)`` method of the `working_set` to see if a 
+        suitable distribution is already active.  (This may raise 
+        ``VersionConflict`` if an unsuitable version of the project is already 
+        active in the specified `working_set`.)  If a suitable distribution 
+        isn't active, this method returns the newest distribution in the 
+        environment that meets the ``Requirement`` in `req`.  If no suitable 
+        distribution is found, and `installer` is supplied, then the result of 
+        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
-        if dist is not None:
-            return dist
-        for dist in self[req.key]:
-            if dist in req:
-                return dist
-        # try to download/install
-        return self.obtain(req, installer)
-
-    def obtain(self, requirement, installer=None):
-        """Obtain a distribution matching `requirement` (e.g. via download)
-
-        Obtain a distro that matches requirement (e.g. via download).  In the
-        base ``Environment`` class, this routine just returns
-        ``installer(requirement)``, unless `installer` is None, in which case
-        None is returned instead.  This method is a hook that allows subclasses
-        to attempt other ways of obtaining a distribution before falling back
-        to the `installer` argument."""
-        if installer is not None:
-            return installer(requirement)
-
-    def __iter__(self):
-        """Yield the unique project names of the available distributions"""
-        for key in self._distmap.keys():
-            if self[key]:
-                yield key
-
-    def __iadd__(self, other):
-        """In-place addition of a distribution or environment"""
-        if isinstance(other, Distribution):
-            self.add(other)
-        elif isinstance(other, Environment):
-            for project in other:
-                for dist in other[project]:
-                    self.add(dist)
-        else:
-            raise TypeError("Can't add %r to environment" % (other,))
-        return self
-
-    def __add__(self, other):
-        """Add an environment or distribution to an environment"""
-        new = self.__class__([], platform=None, python=None)
-        for env in self, other:
-            new += env
-        return new
-
-
-# XXX backward compatibility
-AvailableDistributions = Environment
-
-
-class ExtractionError(RuntimeError):
-    """An error occurred extracting a resource
-
-    The following attributes are available from instances of this exception:
-
-    manager
-        The resource manager that raised this exception
-
-    cache_path
-        The base directory for resource extraction
-
-    original_error
-        The exception instance that caused extraction to fail
-    """
-
-
-class ResourceManager:
-    """Manage resource extraction and packages"""
-    extraction_path = None
-
-    def __init__(self):
-        self.cached_files = {}
-
-    def resource_exists(self, package_or_requirement, resource_name):
-        """Does the named resource exist?"""
-        return get_provider(package_or_requirement).has_resource(resource_name)
-
-    def resource_isdir(self, package_or_requirement, resource_name):
-        """Is the named resource an existing directory?"""
-        return get_provider(package_or_requirement).resource_isdir(
-            resource_name
-        )
-
-    def resource_filename(self, package_or_requirement, resource_name):
-        """Return a true filesystem path for specified resource"""
-        return get_provider(package_or_requirement).get_resource_filename(
-            self, resource_name
-        )
-
-    def resource_stream(self, package_or_requirement, resource_name):
-        """Return a readable file-like object for specified resource"""
-        return get_provider(package_or_requirement).get_resource_stream(
-            self, resource_name
-        )
-
-    def resource_string(self, package_or_requirement, resource_name):
-        """Return specified resource as a string"""
-        return get_provider(package_or_requirement).get_resource_string(
-            self, resource_name
-        )
-
-    def resource_listdir(self, package_or_requirement, resource_name):
-        """List the contents of the named resource directory"""
-        return get_provider(package_or_requirement).resource_listdir(
-            resource_name
-        )
-
-    def extraction_error(self):
-        """Give an error message for problems extracting file(s)"""
-
-        old_exc = sys.exc_info()[1]
-        cache_path = self.extraction_path or get_default_cache()
-
-        tmpl = textwrap.dedent("""
-            Can't extract file(s) to egg cache
-
+        if dist is not None: 
+            return dist 
+        for dist in self[req.key]: 
+            if dist in req: 
+                return dist 
+        # try to download/install 
+        return self.obtain(req, installer) 
+ 
+    def obtain(self, requirement, installer=None): 
+        """Obtain a distribution matching `requirement` (e.g. via download) 
+ 
+        Obtain a distro that matches requirement (e.g. via download).  In the 
+        base ``Environment`` class, this routine just returns 
+        ``installer(requirement)``, unless `installer` is None, in which case 
+        None is returned instead.  This method is a hook that allows subclasses 
+        to attempt other ways of obtaining a distribution before falling back 
+        to the `installer` argument.""" 
+        if installer is not None: 
+            return installer(requirement) 
+ 
+    def __iter__(self): 
+        """Yield the unique project names of the available distributions""" 
+        for key in self._distmap.keys(): 
+            if self[key]: 
+                yield key 
+ 
+    def __iadd__(self, other): 
+        """In-place addition of a distribution or environment""" 
+        if isinstance(other, Distribution): 
+            self.add(other) 
+        elif isinstance(other, Environment): 
+            for project in other: 
+                for dist in other[project]: 
+                    self.add(dist) 
+        else: 
+            raise TypeError("Can't add %r to environment" % (other,)) 
+        return self 
+ 
+    def __add__(self, other): 
+        """Add an environment or distribution to an environment""" 
+        new = self.__class__([], platform=None, python=None) 
+        for env in self, other: 
+            new += env 
+        return new 
+ 
+ 
+# XXX backward compatibility 
+AvailableDistributions = Environment 
+ 
+ 
+class ExtractionError(RuntimeError): 
+    """An error occurred extracting a resource 
+ 
+    The following attributes are available from instances of this exception: 
+ 
+    manager 
+        The resource manager that raised this exception 
+ 
+    cache_path 
+        The base directory for resource extraction 
+ 
+    original_error 
+        The exception instance that caused extraction to fail 
+    """ 
+ 
+ 
+class ResourceManager: 
+    """Manage resource extraction and packages""" 
+    extraction_path = None 
+ 
+    def __init__(self): 
+        self.cached_files = {} 
+ 
+    def resource_exists(self, package_or_requirement, resource_name): 
+        """Does the named resource exist?""" 
+        return get_provider(package_or_requirement).has_resource(resource_name) 
+ 
+    def resource_isdir(self, package_or_requirement, resource_name): 
+        """Is the named resource an existing directory?""" 
+        return get_provider(package_or_requirement).resource_isdir( 
+            resource_name 
+        ) 
+ 
+    def resource_filename(self, package_or_requirement, resource_name): 
+        """Return a true filesystem path for specified resource""" 
+        return get_provider(package_or_requirement).get_resource_filename( 
+            self, resource_name 
+        ) 
+ 
+    def resource_stream(self, package_or_requirement, resource_name): 
+        """Return a readable file-like object for specified resource""" 
+        return get_provider(package_or_requirement).get_resource_stream( 
+            self, resource_name 
+        ) 
+ 
+    def resource_string(self, package_or_requirement, resource_name): 
+        """Return specified resource as a string""" 
+        return get_provider(package_or_requirement).get_resource_string( 
+            self, resource_name 
+        ) 
+ 
+    def resource_listdir(self, package_or_requirement, resource_name): 
+        """List the contents of the named resource directory""" 
+        return get_provider(package_or_requirement).resource_listdir( 
+            resource_name 
+        ) 
+ 
+    def extraction_error(self): 
+        """Give an error message for problems extracting file(s)""" 
+ 
+        old_exc = sys.exc_info()[1] 
+        cache_path = self.extraction_path or get_default_cache() 
+ 
+        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:
-
-              {old_exc}
-
-            The Python egg cache directory is currently set to:
-
-              {cache_path}
-
+ 
+              {old_exc} 
+ 
+            The Python egg cache directory is currently set to: 
+ 
+              {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.
-            """).lstrip()
-        err = ExtractionError(tmpl.format(**locals()))
-        err.manager = self
-        err.cache_path = cache_path
-        err.original_error = old_exc
-        raise err
-
-    def get_cache_path(self, archive_name, names=()):
-        """Return absolute location in cache for `archive_name` and `names`
-
-        The parent directory of the resulting path will be created if it does
-        not already exist.  `archive_name` should be the base filename of the
-        enclosing egg (which may not be the name of the enclosing zipfile!),
-        including its ".egg" extension.  `names`, if provided, should be a
-        sequence of path name parts "under" the egg's extraction location.
-
-        This method should only be called by resource providers that need to
-        obtain an extraction location, and only for names they intend to
-        extract, as it tracks the generated names for possible cleanup later.
-        """
-        extract_path = self.extraction_path or get_default_cache()
+            """).lstrip() 
+        err = ExtractionError(tmpl.format(**locals())) 
+        err.manager = self 
+        err.cache_path = cache_path 
+        err.original_error = old_exc 
+        raise err 
+ 
+    def get_cache_path(self, archive_name, names=()): 
+        """Return absolute location in cache for `archive_name` and `names` 
+ 
+        The parent directory of the resulting path will be created if it does 
+        not already exist.  `archive_name` should be the base filename of the 
+        enclosing egg (which may not be the name of the enclosing zipfile!), 
+        including its ".egg" extension.  `names`, if provided, should be a 
+        sequence of path name parts "under" the egg's extraction location. 
+ 
+        This method should only be called by resource providers that need to 
+        obtain an extraction location, and only for names they intend to 
+        extract, as it tracks the generated names for possible cleanup later. 
+        """ 
+        extract_path = self.extraction_path or get_default_cache() 
         target_path = os.path.join(extract_path, archive_name + '-tmp', *names)
-        try:
-            _bypass_ensure_directory(target_path)
+        try: 
+            _bypass_ensure_directory(target_path) 
         except Exception:
-            self.extraction_error()
-
-        self._warn_unsafe_extraction_path(extract_path)
-
-        self.cached_files[target_path] = 1
-        return target_path
-
-    @staticmethod
-    def _warn_unsafe_extraction_path(path):
-        """
-        If the default extraction path is overridden and set to an insecure
-        location, such as /tmp, it opens up an opportunity for an attacker to
-        replace an extracted file with an unauthorized payload. Warn the user
-        if a known insecure location is used.
-
-        See Distribute #375 for more details.
-        """
-        if os.name == 'nt' and not path.startswith(os.environ['windir']):
-            # On Windows, permissions are generally restrictive by default
-            #  and temp directories are not writable by other users, so
-            #  bypass the warning.
-            return
-        mode = os.stat(path).st_mode
-        if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
+            self.extraction_error() 
+ 
+        self._warn_unsafe_extraction_path(extract_path) 
+ 
+        self.cached_files[target_path] = 1 
+        return target_path 
+ 
+    @staticmethod 
+    def _warn_unsafe_extraction_path(path): 
+        """ 
+        If the default extraction path is overridden and set to an insecure 
+        location, such as /tmp, it opens up an opportunity for an attacker to 
+        replace an extracted file with an unauthorized payload. Warn the user 
+        if a known insecure location is used. 
+ 
+        See Distribute #375 for more details. 
+        """ 
+        if os.name == 'nt' and not path.startswith(os.environ['windir']): 
+            # On Windows, permissions are generally restrictive by default 
+            #  and temp directories are not writable by other users, so 
+            #  bypass the warning. 
+            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 "
-                "when "
-                "used with get_resource_filename. Consider a more secure "
-                "location (set with .set_extraction_path or the "
+                "when " 
+                "used with get_resource_filename. Consider a more secure " 
+                "location (set with .set_extraction_path or the " 
                 "PYTHON_EGG_CACHE environment variable)." % path
             )
-            warnings.warn(msg, UserWarning)
-
-    def postprocess(self, tempname, filename):
-        """Perform any platform-specific postprocessing of `tempname`
-
-        This is where Mac header rewrites should be done; other platforms don't
-        have anything special they should do.
-
-        Resource providers should call this method ONLY after successfully
-        extracting a compressed resource.  They must NOT call it on resources
-        that are already in the filesystem.
-
-        `tempname` is the current (temporary) name of the file, and `filename`
-        is the name it will be renamed to by the caller after this routine
-        returns.
-        """
-
-        if os.name == 'posix':
-            # Make the resource executable
-            mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
-            os.chmod(tempname, mode)
-
-    def set_extraction_path(self, path):
-        """Set the base path where resources will be extracted to, if needed.
-
-        If you do not call this routine before any extractions take place, the
-        path defaults to the return value of ``get_default_cache()``.  (Which
-        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
-        platform-specific fallbacks.  See that routine's documentation for more
-        details.)
-
-        Resources are extracted to subdirectories of this path based upon
-        information given by the ``IResourceProvider``.  You may set this to a
-        temporary directory, but then you must call ``cleanup_resources()`` to
-        delete the extracted files when done.  There is no guarantee that
-        ``cleanup_resources()`` will be able to remove all extracted files.
-
-        (Note: you may not change the extraction path for a given resource
-        manager once resources have been extracted, unless you first call
-        ``cleanup_resources()``.)
-        """
-        if self.cached_files:
-            raise ValueError(
-                "Can't change extraction path, files already extracted"
-            )
-
-        self.extraction_path = path
-
-    def cleanup_resources(self, force=False):
-        """
-        Delete all extracted resource files and directories, returning a list
-        of the file and directory names that could not be successfully removed.
-        This function does not have any concurrency protection, so it should
-        generally only be called when the extraction path is a temporary
-        directory exclusive to a single process.  This method is not
-        automatically called; you must call it explicitly or register it as an
-        ``atexit`` function if you wish to ensure cleanup of a temporary
-        directory used for extractions.
-        """
-        # XXX
-
-
-def get_default_cache():
-    """
+            warnings.warn(msg, UserWarning) 
+ 
+    def postprocess(self, tempname, filename): 
+        """Perform any platform-specific postprocessing of `tempname` 
+ 
+        This is where Mac header rewrites should be done; other platforms don't 
+        have anything special they should do. 
+ 
+        Resource providers should call this method ONLY after successfully 
+        extracting a compressed resource.  They must NOT call it on resources 
+        that are already in the filesystem. 
+ 
+        `tempname` is the current (temporary) name of the file, and `filename` 
+        is the name it will be renamed to by the caller after this routine 
+        returns. 
+        """ 
+ 
+        if os.name == 'posix': 
+            # Make the resource executable 
+            mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777 
+            os.chmod(tempname, mode) 
+ 
+    def set_extraction_path(self, path): 
+        """Set the base path where resources will be extracted to, if needed. 
+ 
+        If you do not call this routine before any extractions take place, the 
+        path defaults to the return value of ``get_default_cache()``.  (Which 
+        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various 
+        platform-specific fallbacks.  See that routine's documentation for more 
+        details.) 
+ 
+        Resources are extracted to subdirectories of this path based upon 
+        information given by the ``IResourceProvider``.  You may set this to a 
+        temporary directory, but then you must call ``cleanup_resources()`` to 
+        delete the extracted files when done.  There is no guarantee that 
+        ``cleanup_resources()`` will be able to remove all extracted files. 
+ 
+        (Note: you may not change the extraction path for a given resource 
+        manager once resources have been extracted, unless you first call 
+        ``cleanup_resources()``.) 
+        """ 
+        if self.cached_files: 
+            raise ValueError( 
+                "Can't change extraction path, files already extracted" 
+            ) 
+ 
+        self.extraction_path = path 
+ 
+    def cleanup_resources(self, force=False): 
+        """ 
+        Delete all extracted resource files and directories, returning a list 
+        of the file and directory names that could not be successfully removed. 
+        This function does not have any concurrency protection, so it should 
+        generally only be called when the extraction path is a temporary 
+        directory exclusive to a single process.  This method is not 
+        automatically called; you must call it explicitly or register it as an 
+        ``atexit`` function if you wish to ensure cleanup of a temporary 
+        directory used for extractions. 
+        """ 
+        # XXX 
+ 
+
+def get_default_cache(): 
+    """ 
     Return the ``PYTHON_EGG_CACHE`` environment variable
     or a platform-relevant user cache dir for an app
     named "Python-Eggs".
@@ -1312,45 +1312,45 @@ def get_default_cache():
         os.environ.get('PYTHON_EGG_CACHE')
         or appdirs.user_cache_dir(appname='Python-Eggs')
     )
-
-
-def safe_name(name):
-    """Convert an arbitrary string to a standard distribution name
-
-    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
-    """
-    return re.sub('[^A-Za-z0-9.]+', '-', name)
-
-
-def safe_version(version):
-    """
-    Convert an arbitrary string to a standard version string
-    """
-    try:
-        # normalize the version
-        return str(packaging.version.Version(version))
-    except packaging.version.InvalidVersion:
+ 
+ 
+def safe_name(name): 
+    """Convert an arbitrary string to a standard distribution name 
+ 
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'. 
+    """ 
+    return re.sub('[^A-Za-z0-9.]+', '-', name) 
+ 
+ 
+def safe_version(version): 
+    """ 
+    Convert an arbitrary string to a standard version string 
+    """ 
+    try: 
+        # normalize the version 
+        return str(packaging.version.Version(version)) 
+    except packaging.version.InvalidVersion: 
         version = version.replace(' ', '.')
-        return re.sub('[^A-Za-z0-9.]+', '-', version)
-
-
-def safe_extra(extra):
-    """Convert an arbitrary string to a standard 'extra' name
-
-    Any runs of non-alphanumeric characters are replaced with a single '_',
-    and the result is always lowercased.
-    """
+        return re.sub('[^A-Za-z0-9.]+', '-', version) 
+ 
+ 
+def safe_extra(extra): 
+    """Convert an arbitrary string to a standard 'extra' name 
+ 
+    Any runs of non-alphanumeric characters are replaced with a single '_', 
+    and the result is always lowercased. 
+    """ 
     return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
-
-
-def to_filename(name):
-    """Convert a project or version name to its filename-escaped form
-
-    Any '-' characters are currently replaced with '_'.
-    """
+ 
+ 
+def to_filename(name): 
+    """Convert a project or version name to its filename-escaped form 
+ 
+    Any '-' characters are currently replaced with '_'. 
+    """ 
     return name.replace('-', '_')
-
-
+ 
+ 
 def invalid_marker(text):
     """
     Validate text as a PEP 508 environment marker; return an exception
@@ -1363,14 +1363,14 @@ def invalid_marker(text):
         e.lineno = None
         return e
     return False
-
-
+ 
+ 
 def evaluate_marker(text, extra=None):
     """
     Evaluate a PEP 508 environment marker.
     Return a boolean indicating the marker result in this environment.
     Raise SyntaxError if marker is invalid.
-
+ 
     This implementation uses the 'pyparsing' module.
     """
     try:
@@ -1378,38 +1378,38 @@ def evaluate_marker(text, extra=None):
         return marker.evaluate()
     except packaging.markers.InvalidMarker as e:
         raise SyntaxError(e)
-
-
-class NullProvider:
-    """Try to implement resources and metadata for arbitrary PEP 302 loaders"""
-
-    egg_name = None
-    egg_info = None
-    loader = None
-
-    def __init__(self, module):
-        self.loader = getattr(module, '__loader__', None)
-        self.module_path = os.path.dirname(getattr(module, '__file__', ''))
-
-    def get_resource_filename(self, manager, resource_name):
-        return self._fn(self.module_path, resource_name)
-
-    def get_resource_stream(self, manager, resource_name):
-        return io.BytesIO(self.get_resource_string(manager, resource_name))
-
-    def get_resource_string(self, manager, resource_name):
-        return self._get(self._fn(self.module_path, resource_name))
-
-    def has_resource(self, resource_name):
-        return self._has(self._fn(self.module_path, resource_name))
-
+ 
+ 
+class NullProvider: 
+    """Try to implement resources and metadata for arbitrary PEP 302 loaders""" 
+ 
+    egg_name = None 
+    egg_info = None 
+    loader = None 
+ 
+    def __init__(self, module): 
+        self.loader = getattr(module, '__loader__', None) 
+        self.module_path = os.path.dirname(getattr(module, '__file__', '')) 
+ 
+    def get_resource_filename(self, manager, resource_name): 
+        return self._fn(self.module_path, resource_name) 
+ 
+    def get_resource_stream(self, manager, resource_name): 
+        return io.BytesIO(self.get_resource_string(manager, resource_name)) 
+ 
+    def get_resource_string(self, manager, resource_name): 
+        return self._get(self._fn(self.module_path, resource_name)) 
+ 
+    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 has_metadata(self, 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)
 
@@ -1427,68 +1427,68 @@ class NullProvider:
             # 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))
-
-    def resource_isdir(self, resource_name):
-        return self._isdir(self._fn(self.module_path, resource_name))
-
-    def metadata_isdir(self, name):
-        return self.egg_info and self._isdir(self._fn(self.egg_info, name))
-
-    def resource_listdir(self, resource_name):
-        return self._listdir(self._fn(self.module_path, resource_name))
-
-    def metadata_listdir(self, name):
-        if self.egg_info:
-            return self._listdir(self._fn(self.egg_info, name))
-        return []
-
-    def run_script(self, script_name, namespace):
+ 
+    def get_metadata_lines(self, name): 
+        return yield_lines(self.get_metadata(name)) 
+ 
+    def resource_isdir(self, resource_name): 
+        return self._isdir(self._fn(self.module_path, resource_name)) 
+ 
+    def metadata_isdir(self, name): 
+        return self.egg_info and self._isdir(self._fn(self.egg_info, name)) 
+ 
+    def resource_listdir(self, resource_name): 
+        return self._listdir(self._fn(self.module_path, resource_name)) 
+ 
+    def metadata_listdir(self, name): 
+        if self.egg_info: 
+            return self._listdir(self._fn(self.egg_info, name)) 
+        return [] 
+ 
+    def run_script(self, script_name, namespace): 
         script = 'scripts/' + script_name
-        if not self.has_metadata(script):
+        if not self.has_metadata(script): 
             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)
-        namespace['__file__'] = script_filename
-        if os.path.exists(script_filename):
-            source = open(script_filename).read()
-            code = compile(source, script_filename, 'exec')
-            exec(code, namespace, namespace)
-        else:
-            from linecache import cache
-            cache[script_filename] = (
-                len(script_text), 0, script_text.split('\n'), script_filename
-            )
+        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) 
+        namespace['__file__'] = script_filename 
+        if os.path.exists(script_filename): 
+            source = open(script_filename).read() 
+            code = compile(source, script_filename, 'exec') 
+            exec(code, namespace, namespace) 
+        else: 
+            from linecache import cache 
+            cache[script_filename] = ( 
+                len(script_text), 0, script_text.split('\n'), script_filename 
+            ) 
             script_code = compile(script_text, script_filename, 'exec')
-            exec(script_code, namespace, namespace)
-
-    def _has(self, path):
-        raise NotImplementedError(
-            "Can't perform this operation for unregistered loader type"
-        )
-
-    def _isdir(self, path):
-        raise NotImplementedError(
-            "Can't perform this operation for unregistered loader type"
-        )
-
-    def _listdir(self, path):
-        raise NotImplementedError(
-            "Can't perform this operation for unregistered loader type"
-        )
-
-    def _fn(self, base, resource_name):
+            exec(script_code, namespace, namespace) 
+ 
+    def _has(self, path): 
+        raise NotImplementedError( 
+            "Can't perform this operation for unregistered loader type" 
+        ) 
+ 
+    def _isdir(self, path): 
+        raise NotImplementedError( 
+            "Can't perform this operation for unregistered loader type" 
+        ) 
+ 
+    def _listdir(self, path): 
+        raise NotImplementedError( 
+            "Can't perform this operation for unregistered loader type" 
+        ) 
+ 
+    def _fn(self, base, resource_name): 
         self._validate_resource_path(resource_name)
-        if resource_name:
-            return os.path.join(base, *resource_name.split('/'))
-        return base
-
+        if resource_name: 
+            return os.path.join(base, *resource_name.split('/')) 
+        return base 
+ 
     @staticmethod
     def _validate_resource_path(path):
         """
@@ -1564,74 +1564,74 @@ is not allowed.
             stacklevel=4,
         )
 
-    def _get(self, path):
-        if hasattr(self.loader, 'get_data'):
-            return self.loader.get_data(path)
-        raise NotImplementedError(
-            "Can't perform this operation for loaders without 'get_data()'"
-        )
-
-
-register_loader_type(object, NullProvider)
-
-
-class EggProvider(NullProvider):
-    """Provider based on a virtual filesystem"""
-
-    def __init__(self, module):
-        NullProvider.__init__(self, module)
-        self._setup_prefix()
-
-    def _setup_prefix(self):
-        # we assume here that our metadata may be nested inside a "basket"
-        # of multiple eggs; that's why we use module_path instead of .archive
-        path = self.module_path
-        old = None
+    def _get(self, path): 
+        if hasattr(self.loader, 'get_data'): 
+            return self.loader.get_data(path) 
+        raise NotImplementedError( 
+            "Can't perform this operation for loaders without 'get_data()'" 
+        ) 
+ 
+
+register_loader_type(object, NullProvider) 
+ 
+ 
+class EggProvider(NullProvider): 
+    """Provider based on a virtual filesystem""" 
+ 
+    def __init__(self, module): 
+        NullProvider.__init__(self, module) 
+        self._setup_prefix() 
+ 
+    def _setup_prefix(self): 
+        # we assume here that our metadata may be nested inside a "basket" 
+        # of multiple eggs; that's why we use module_path instead of .archive 
+        path = self.module_path 
+        old = None 
         while path != old:
             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
-                break
-            old = path
-            path, base = os.path.split(path)
-
-
-class DefaultProvider(EggProvider):
-    """Provides access to package resources in the filesystem"""
-
-    def _has(self, path):
-        return os.path.exists(path)
-
-    def _isdir(self, path):
-        return os.path.isdir(path)
-
-    def _listdir(self, path):
-        return os.listdir(path)
-
-    def get_resource_stream(self, manager, resource_name):
-        return open(self._fn(self.module_path, resource_name), 'rb')
-
-    def _get(self, path):
-        with open(path, 'rb') as stream:
-            return stream.read()
-
-    @classmethod
-    def _register(cls):
+                self.egg_name = os.path.basename(path) 
+                self.egg_info = os.path.join(path, 'EGG-INFO') 
+                self.egg_root = path 
+                break 
+            old = path 
+            path, base = os.path.split(path) 
+ 
+
+class DefaultProvider(EggProvider): 
+    """Provides access to package resources in the filesystem""" 
+ 
+    def _has(self, path): 
+        return os.path.exists(path) 
+ 
+    def _isdir(self, path): 
+        return os.path.isdir(path) 
+ 
+    def _listdir(self, path): 
+        return os.listdir(path) 
+ 
+    def get_resource_stream(self, manager, resource_name): 
+        return open(self._fn(self.module_path, resource_name), 'rb') 
+ 
+    def _get(self, path): 
+        with open(path, 'rb') as stream: 
+            return stream.read() 
+ 
+    @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)
-
-
-DefaultProvider._register()
-
-
-class EmptyProvider(NullProvider):
-    """Provider that returns nothing for all requests"""
-
-    module_path = None
-
+ 
+
+DefaultProvider._register() 
+ 
+ 
+class EmptyProvider(NullProvider): 
+    """Provider that returns nothing for all requests""" 
+ 
+    module_path = None 
+ 
     _isdir = _has = lambda self, path: False
 
     def _get(self, path):
@@ -1640,260 +1640,260 @@ class EmptyProvider(NullProvider):
     def _listdir(self, path):
         return []
 
-    def __init__(self):
-        pass
-
-
-empty_provider = EmptyProvider()
-
-
-class ZipManifests(dict):
-    """
-    zip manifest builder
-    """
-
-    @classmethod
-    def build(cls, path):
-        """
-        Build a dictionary similar to the zipimport directory
-        caches, except instead of tuples, store ZipInfo objects.
-
-        Use a platform-specific path separator (os.sep) for the path keys
-        for compatibility with pypy on Windows.
-        """
+    def __init__(self): 
+        pass 
+ 
+
+empty_provider = EmptyProvider() 
+ 
+ 
+class ZipManifests(dict): 
+    """ 
+    zip manifest builder 
+    """ 
+ 
+    @classmethod 
+    def build(cls, path): 
+        """ 
+        Build a dictionary similar to the zipimport directory 
+        caches, except instead of tuples, store ZipInfo objects. 
+ 
+        Use a platform-specific path separator (os.sep) for the path keys 
+        for compatibility with pypy on Windows. 
+        """ 
         with zipfile.ZipFile(path) as zfile:
-            items = (
-                (
-                    name.replace('/', os.sep),
-                    zfile.getinfo(name),
-                )
-                for name in zfile.namelist()
-            )
-            return dict(items)
-
-    load = build
-
-
-class MemoizedZipManifests(ZipManifests):
-    """
-    Memoized zipfile manifests.
-    """
-    manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime')
-
-    def load(self, path):
-        """
-        Load a manifest at path or return a suitable manifest already loaded.
-        """
-        path = os.path.normpath(path)
-        mtime = os.stat(path).st_mtime
-
-        if path not in self or self[path].mtime != mtime:
-            manifest = self.build(path)
-            self[path] = self.manifest_mod(manifest, mtime)
-
-        return self[path].manifest
-
-
-class ZipProvider(EggProvider):
-    """Resource support for zips and eggs"""
-
-    eagers = None
-    _zip_manifests = MemoizedZipManifests()
-
-    def __init__(self, module):
-        EggProvider.__init__(self, module)
+            items = ( 
+                ( 
+                    name.replace('/', os.sep), 
+                    zfile.getinfo(name), 
+                ) 
+                for name in zfile.namelist() 
+            ) 
+            return dict(items) 
+ 
+    load = build 
+ 
+ 
+class MemoizedZipManifests(ZipManifests): 
+    """ 
+    Memoized zipfile manifests. 
+    """ 
+    manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime') 
+ 
+    def load(self, path): 
+        """ 
+        Load a manifest at path or return a suitable manifest already loaded. 
+        """ 
+        path = os.path.normpath(path) 
+        mtime = os.stat(path).st_mtime 
+ 
+        if path not in self or self[path].mtime != mtime: 
+            manifest = self.build(path) 
+            self[path] = self.manifest_mod(manifest, mtime) 
+ 
+        return self[path].manifest 
+ 
+ 
+class ZipProvider(EggProvider): 
+    """Resource support for zips and eggs""" 
+ 
+    eagers = None 
+    _zip_manifests = MemoizedZipManifests() 
+ 
+    def __init__(self, module): 
+        EggProvider.__init__(self, module) 
         self.zip_pre = self.loader.archive + os.sep
-
-    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
+ 
+    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 ''
-        if fspath.startswith(self.zip_pre):
-            return fspath[len(self.zip_pre):]
-        raise AssertionError(
-            "%s is not a subpath of %s" % (fspath, self.zip_pre)
-        )
-
-    def _parts(self, zip_path):
-        # Convert a zipfile subpath into an egg-relative path part list.
-        # pseudo-fs path
+        if fspath.startswith(self.zip_pre): 
+            return fspath[len(self.zip_pre):] 
+        raise AssertionError( 
+            "%s is not a subpath of %s" % (fspath, self.zip_pre) 
+        ) 
+ 
+    def _parts(self, zip_path): 
+        # Convert a zipfile subpath into an egg-relative path part list. 
+        # pseudo-fs path 
         fspath = self.zip_pre + zip_path
         if fspath.startswith(self.egg_root + os.sep):
             return fspath[len(self.egg_root) + 1:].split(os.sep)
-        raise AssertionError(
-            "%s is not a subpath of %s" % (fspath, self.egg_root)
-        )
-
-    @property
-    def zipinfo(self):
-        return self._zip_manifests.load(self.loader.archive)
-
-    def get_resource_filename(self, manager, resource_name):
-        if not self.egg_name:
-            raise NotImplementedError(
-                "resource_filename() only supported for .egg, not .zip"
-            )
-        # no need to lock for extraction, since we use temp names
-        zip_path = self._resource_to_zip(resource_name)
-        eagers = self._get_eager_resources()
-        if '/'.join(self._parts(zip_path)) in eagers:
-            for name in eagers:
-                self._extract_resource(manager, self._eager_to_zip(name))
-        return self._extract_resource(manager, zip_path)
-
-    @staticmethod
-    def _get_date_and_size(zip_stat):
-        size = zip_stat.file_size
-        # ymdhms+wday, yday, dst
-        date_time = zip_stat.date_time + (0, 0, -1)
-        # 1980 offset already done
-        timestamp = time.mktime(date_time)
-        return timestamp, size
-
-    def _extract_resource(self, manager, zip_path):
-
-        if zip_path in self._index():
-            for name in self._index()[zip_path]:
-                last = self._extract_resource(
-                    manager, os.path.join(zip_path, name)
-                )
-            # return the extracted directory name
-            return os.path.dirname(last)
-
-        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
-
-        if not WRITE_SUPPORT:
-            raise IOError('"os.rename" and "os.unlink" are not supported '
-                          'on this platform')
-        try:
-
-            real_path = manager.get_cache_path(
-                self.egg_name, self._parts(zip_path)
-            )
-
-            if self._is_current(real_path, zip_path):
-                return real_path
-
+        raise AssertionError( 
+            "%s is not a subpath of %s" % (fspath, self.egg_root) 
+        ) 
+ 
+    @property 
+    def zipinfo(self): 
+        return self._zip_manifests.load(self.loader.archive) 
+ 
+    def get_resource_filename(self, manager, resource_name): 
+        if not self.egg_name: 
+            raise NotImplementedError( 
+                "resource_filename() only supported for .egg, not .zip" 
+            ) 
+        # no need to lock for extraction, since we use temp names 
+        zip_path = self._resource_to_zip(resource_name) 
+        eagers = self._get_eager_resources() 
+        if '/'.join(self._parts(zip_path)) in eagers: 
+            for name in eagers: 
+                self._extract_resource(manager, self._eager_to_zip(name)) 
+        return self._extract_resource(manager, zip_path) 
+ 
+    @staticmethod 
+    def _get_date_and_size(zip_stat): 
+        size = zip_stat.file_size 
+        # ymdhms+wday, yday, dst 
+        date_time = zip_stat.date_time + (0, 0, -1) 
+        # 1980 offset already done 
+        timestamp = time.mktime(date_time) 
+        return timestamp, size 
+ 
+    def _extract_resource(self, manager, zip_path): 
+ 
+        if zip_path in self._index(): 
+            for name in self._index()[zip_path]: 
+                last = self._extract_resource( 
+                    manager, os.path.join(zip_path, name) 
+                ) 
+            # return the extracted directory name 
+            return os.path.dirname(last) 
+ 
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path]) 
+ 
+        if not WRITE_SUPPORT: 
+            raise IOError('"os.rename" and "os.unlink" are not supported ' 
+                          'on this platform') 
+        try: 
+ 
+            real_path = manager.get_cache_path( 
+                self.egg_name, self._parts(zip_path) 
+            ) 
+ 
+            if self._is_current(real_path, zip_path): 
+                return 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))
-            manager.postprocess(tmpnam, real_path)
-
-            try:
-                rename(tmpnam, real_path)
-
-            except os.error:
-                if os.path.isfile(real_path):
-                    if self._is_current(real_path, zip_path):
-                        # the file became current since it was checked above,
-                        #  so proceed.
-                        return real_path
-                    # Windows, del old file and retry
+            os.write(outf, self.loader.get_data(zip_path)) 
+            os.close(outf) 
+            utime(tmpnam, (timestamp, timestamp)) 
+            manager.postprocess(tmpnam, real_path) 
+ 
+            try: 
+                rename(tmpnam, real_path) 
+ 
+            except os.error: 
+                if os.path.isfile(real_path): 
+                    if self._is_current(real_path, zip_path): 
+                        # the file became current since it was checked above, 
+                        #  so proceed. 
+                        return real_path 
+                    # Windows, del old file and retry 
                     elif os.name == 'nt':
-                        unlink(real_path)
-                        rename(tmpnam, real_path)
-                        return real_path
-                raise
-
-        except os.error:
-            # report a user-friendly error
-            manager.extraction_error()
-
-        return real_path
-
-    def _is_current(self, file_path, zip_path):
-        """
-        Return True if the file_path is current for this zip_path
-        """
-        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
-        if not os.path.isfile(file_path):
-            return False
-        stat = os.stat(file_path)
+                        unlink(real_path) 
+                        rename(tmpnam, real_path) 
+                        return real_path 
+                raise 
+ 
+        except os.error: 
+            # report a user-friendly error 
+            manager.extraction_error() 
+ 
+        return real_path 
+ 
+    def _is_current(self, file_path, zip_path): 
+        """ 
+        Return True if the file_path is current for this zip_path 
+        """ 
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path]) 
+        if not os.path.isfile(file_path): 
+            return False 
+        stat = os.stat(file_path) 
         if stat.st_size != size or stat.st_mtime != timestamp:
-            return False
-        # check that the contents match
-        zip_contents = self.loader.get_data(zip_path)
-        with open(file_path, 'rb') as f:
-            file_contents = f.read()
-        return zip_contents == file_contents
-
-    def _get_eager_resources(self):
-        if self.eagers is None:
-            eagers = []
-            for name in ('native_libs.txt', 'eager_resources.txt'):
-                if self.has_metadata(name):
-                    eagers.extend(self.get_metadata_lines(name))
-            self.eagers = eagers
-        return self.eagers
-
-    def _index(self):
-        try:
-            return self._dirindex
-        except AttributeError:
-            ind = {}
-            for path in self.zipinfo:
-                parts = path.split(os.sep)
-                while parts:
-                    parent = os.sep.join(parts[:-1])
-                    if parent in ind:
-                        ind[parent].append(parts[-1])
-                        break
-                    else:
-                        ind[parent] = [parts.pop()]
-            self._dirindex = ind
-            return ind
-
-    def _has(self, fspath):
-        zip_path = self._zipinfo_name(fspath)
-        return zip_path in self.zipinfo or zip_path in self._index()
-
-    def _isdir(self, fspath):
-        return self._zipinfo_name(fspath) in self._index()
-
-    def _listdir(self, fspath):
-        return list(self._index().get(self._zipinfo_name(fspath), ()))
-
-    def _eager_to_zip(self, resource_name):
-        return self._zipinfo_name(self._fn(self.egg_root, resource_name))
-
-    def _resource_to_zip(self, resource_name):
-        return self._zipinfo_name(self._fn(self.module_path, resource_name))
-
-
-register_loader_type(zipimport.zipimporter, ZipProvider)
-
-
-class FileMetadata(EmptyProvider):
-    """Metadata handler for standalone PKG-INFO files
-
-    Usage::
-
-        metadata = FileMetadata("/path/to/PKG-INFO")
-
-    This provider rejects all data and metadata requests except for PKG-INFO,
-    which is treated as existing, and will be the contents of the file at
-    the provided location.
-    """
-
-    def __init__(self, path):
-        self.path = path
-
+            return False 
+        # check that the contents match 
+        zip_contents = self.loader.get_data(zip_path) 
+        with open(file_path, 'rb') as f: 
+            file_contents = f.read() 
+        return zip_contents == file_contents 
+ 
+    def _get_eager_resources(self): 
+        if self.eagers is None: 
+            eagers = [] 
+            for name in ('native_libs.txt', 'eager_resources.txt'): 
+                if self.has_metadata(name): 
+                    eagers.extend(self.get_metadata_lines(name)) 
+            self.eagers = eagers 
+        return self.eagers 
+ 
+    def _index(self): 
+        try: 
+            return self._dirindex 
+        except AttributeError: 
+            ind = {} 
+            for path in self.zipinfo: 
+                parts = path.split(os.sep) 
+                while parts: 
+                    parent = os.sep.join(parts[:-1]) 
+                    if parent in ind: 
+                        ind[parent].append(parts[-1]) 
+                        break 
+                    else: 
+                        ind[parent] = [parts.pop()] 
+            self._dirindex = ind 
+            return ind 
+ 
+    def _has(self, fspath): 
+        zip_path = self._zipinfo_name(fspath) 
+        return zip_path in self.zipinfo or zip_path in self._index() 
+ 
+    def _isdir(self, fspath): 
+        return self._zipinfo_name(fspath) in self._index() 
+ 
+    def _listdir(self, fspath): 
+        return list(self._index().get(self._zipinfo_name(fspath), ())) 
+ 
+    def _eager_to_zip(self, resource_name): 
+        return self._zipinfo_name(self._fn(self.egg_root, resource_name)) 
+ 
+    def _resource_to_zip(self, resource_name): 
+        return self._zipinfo_name(self._fn(self.module_path, resource_name)) 
+ 
+
+register_loader_type(zipimport.zipimporter, ZipProvider) 
+ 
+ 
+class FileMetadata(EmptyProvider): 
+    """Metadata handler for standalone PKG-INFO files 
+ 
+    Usage:: 
+ 
+        metadata = FileMetadata("/path/to/PKG-INFO") 
+ 
+    This provider rejects all data and metadata requests except for PKG-INFO, 
+    which is treated as existing, and will be the contents of the file at 
+    the provided location. 
+    """ 
+ 
+    def __init__(self, path): 
+        self.path = path 
+ 
     def _get_metadata_path(self, name):
         return self.path
 
-    def has_metadata(self, name):
+    def has_metadata(self, name): 
         return name == 'PKG-INFO' and os.path.isfile(self.path)
-
-    def get_metadata(self, name):
+ 
+    def get_metadata(self, name): 
         if name != 'PKG-INFO':
             raise KeyError("No metadata except PKG-INFO is available")
-
+ 
         with io.open(self.path, encoding='utf-8', errors="replace") as f:
             metadata = f.read()
         self._warn_on_replacement(metadata)
@@ -1907,106 +1907,106 @@ class FileMetadata(EmptyProvider):
             msg = tmpl.format(**locals())
             warnings.warn(msg)
 
-    def get_metadata_lines(self, name):
-        return yield_lines(self.get_metadata(name))
-
-
-class PathMetadata(DefaultProvider):
-    """Metadata provider for egg directories
-
-    Usage::
-
-        # Development eggs:
-
-        egg_info = "/path/to/PackageName.egg-info"
-        base_dir = os.path.dirname(egg_info)
-        metadata = PathMetadata(base_dir, egg_info)
-        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
-        dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
-
-        # Unpacked egg directories:
-
-        egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
-        metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
-        dist = Distribution.from_filename(egg_path, metadata=metadata)
-    """
-
-    def __init__(self, path, egg_info):
-        self.module_path = path
-        self.egg_info = egg_info
-
-
-class EggMetadata(ZipProvider):
-    """Metadata provider for .egg files"""
-
-    def __init__(self, importer):
-        """Create a metadata provider from a zipimporter"""
-
+    def get_metadata_lines(self, name): 
+        return yield_lines(self.get_metadata(name)) 
+ 
+ 
+class PathMetadata(DefaultProvider): 
+    """Metadata provider for egg directories 
+ 
+    Usage:: 
+ 
+        # Development eggs: 
+ 
+        egg_info = "/path/to/PackageName.egg-info" 
+        base_dir = os.path.dirname(egg_info) 
+        metadata = PathMetadata(base_dir, egg_info) 
+        dist_name = os.path.splitext(os.path.basename(egg_info))[0] 
+        dist = Distribution(basedir, project_name=dist_name, metadata=metadata) 
+ 
+        # Unpacked egg directories: 
+ 
+        egg_path = "/path/to/PackageName-ver-pyver-etc.egg" 
+        metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO')) 
+        dist = Distribution.from_filename(egg_path, metadata=metadata) 
+    """ 
+ 
+    def __init__(self, path, egg_info): 
+        self.module_path = path 
+        self.egg_info = egg_info 
+ 
+ 
+class EggMetadata(ZipProvider): 
+    """Metadata provider for .egg files""" 
+ 
+    def __init__(self, importer): 
+        """Create a metadata provider from a zipimporter""" 
+ 
         self.zip_pre = importer.archive + os.sep
-        self.loader = importer
-        if importer.prefix:
-            self.module_path = os.path.join(importer.archive, importer.prefix)
-        else:
-            self.module_path = importer.archive
-        self._setup_prefix()
-
-
+        self.loader = importer 
+        if importer.prefix: 
+            self.module_path = os.path.join(importer.archive, importer.prefix) 
+        else: 
+            self.module_path = importer.archive 
+        self._setup_prefix() 
+ 
+ 
 _declare_state('dict', _distribution_finders={})
 
 
-def register_finder(importer_type, distribution_finder):
-    """Register `distribution_finder` to find distributions in sys.path items
-
-    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
-    handler), and `distribution_finder` is a callable that, passed a path
-    item and the importer instance, yields ``Distribution`` instances found on
-    that path item.  See ``pkg_resources.find_on_path`` for an example."""
-    _distribution_finders[importer_type] = distribution_finder
-
-
-def find_distributions(path_item, only=False):
-    """Yield distributions accessible via `path_item`"""
-    importer = get_importer(path_item)
-    finder = _find_adapter(_distribution_finders, importer)
-    return finder(importer, path_item, only)
-
-
-def find_eggs_in_zip(importer, path_item, only=False):
-    """
-    Find eggs in zip files; possibly multiple nested eggs.
-    """
-    if importer.archive.endswith('.whl'):
-        # wheels are not supported with this finder
-        # they don't have PKG-INFO metadata, and won't ever contain eggs
-        return
-    metadata = EggMetadata(importer)
-    if metadata.has_metadata('PKG-INFO'):
-        yield Distribution.from_filename(path_item, metadata=metadata)
-    if only:
-        # don't yield nested distros
-        return
+def register_finder(importer_type, distribution_finder): 
+    """Register `distribution_finder` to find distributions in sys.path items 
+ 
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item 
+    handler), and `distribution_finder` is a callable that, passed a path 
+    item and the importer instance, yields ``Distribution`` instances found on 
+    that path item.  See ``pkg_resources.find_on_path`` for an example.""" 
+    _distribution_finders[importer_type] = distribution_finder 
+ 
+ 
+def find_distributions(path_item, only=False): 
+    """Yield distributions accessible via `path_item`""" 
+    importer = get_importer(path_item) 
+    finder = _find_adapter(_distribution_finders, importer) 
+    return finder(importer, path_item, only) 
+ 
+
+def find_eggs_in_zip(importer, path_item, only=False): 
+    """ 
+    Find eggs in zip files; possibly multiple nested eggs. 
+    """ 
+    if importer.archive.endswith('.whl'): 
+        # wheels are not supported with this finder 
+        # they don't have PKG-INFO metadata, and won't ever contain eggs 
+        return 
+    metadata = EggMetadata(importer) 
+    if metadata.has_metadata('PKG-INFO'): 
+        yield Distribution.from_filename(path_item, metadata=metadata) 
+    if only: 
+        # don't yield nested distros 
+        return 
     for subitem in metadata.resource_listdir(''):
         if _is_egg_path(subitem):
-            subpath = os.path.join(path_item, subitem)
+            subpath = os.path.join(path_item, subitem) 
             dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
             for dist in dists:
-                yield dist
+                yield dist 
         elif subitem.lower().endswith('.dist-info'):
             subpath = os.path.join(path_item, subitem)
             submeta = EggMetadata(zipimport.zipimporter(subpath))
             submeta.egg_info = subpath
             yield Distribution.from_location(path_item, subitem, submeta)
+ 
 
+register_finder(zipimport.zipimporter, find_eggs_in_zip) 
+ 
 
-register_finder(zipimport.zipimporter, find_eggs_in_zip)
-
+def find_nothing(importer, path_item, only=False): 
+    return () 
 
-def find_nothing(importer, path_item, only=False):
-    return ()
-
-
-register_finder(object, find_nothing)
 
+register_finder(object, find_nothing) 
+ 
 
 def _by_version_descending(names):
     """
@@ -2034,15 +2034,15 @@ def _by_version_descending(names):
     return sorted(names, key=_by_version, reverse=True)
 
 
-def find_on_path(importer, path_item, only=False):
-    """Yield distributions accessible on a sys.path directory"""
-    path_item = _normalize_cached(path_item)
-
+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')
-            )
+            ) 
         )
         return
 
@@ -2161,73 +2161,73 @@ def resolve_egg_link(path):
     return next(dist_groups, ())
 
 
-register_finder(pkgutil.ImpImporter, find_on_path)
-
-if hasattr(importlib_machinery, 'FileFinder'):
-    register_finder(importlib_machinery.FileFinder, find_on_path)
-
-_declare_state('dict', _namespace_handlers={})
-_declare_state('dict', _namespace_packages={})
-
-
-def register_namespace_handler(importer_type, namespace_handler):
-    """Register `namespace_handler` to declare namespace packages
-
-    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
-    handler), and `namespace_handler` is a callable like this::
-
-        def namespace_handler(importer, path_entry, moduleName, module):
-            # return a path_entry to use for child packages
-
-    Namespace handlers are only called if the importer object has already
-    agreed that it can handle the relevant path item, and they should only
-    return a subpath if the module __path__ does not already contain an
-    equivalent subpath.  For an example namespace handler, see
-    ``pkg_resources.file_ns_handler``.
-    """
-    _namespace_handlers[importer_type] = namespace_handler
-
-
-def _handle_ns(packageName, path_item):
-    """Ensure that named package includes a subpath of path_item (if needed)"""
-
-    importer = get_importer(path_item)
-    if importer is None:
-        return None
+register_finder(pkgutil.ImpImporter, find_on_path) 
+ 
+if hasattr(importlib_machinery, 'FileFinder'): 
+    register_finder(importlib_machinery.FileFinder, find_on_path) 
+ 
+_declare_state('dict', _namespace_handlers={}) 
+_declare_state('dict', _namespace_packages={}) 
+ 
+ 
+def register_namespace_handler(importer_type, namespace_handler): 
+    """Register `namespace_handler` to declare namespace packages 
+ 
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item 
+    handler), and `namespace_handler` is a callable like this:: 
+ 
+        def namespace_handler(importer, path_entry, moduleName, module): 
+            # return a path_entry to use for child packages 
+ 
+    Namespace handlers are only called if the importer object has already 
+    agreed that it can handle the relevant path item, and they should only 
+    return a subpath if the module __path__ does not already contain an 
+    equivalent subpath.  For an example namespace handler, see 
+    ``pkg_resources.file_ns_handler``. 
+    """ 
+    _namespace_handlers[importer_type] = namespace_handler 
+ 
+
+def _handle_ns(packageName, path_item): 
+    """Ensure that named package includes a subpath of path_item (if needed)""" 
+ 
+    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)
 
-    if loader is None:
-        return None
-    module = sys.modules.get(packageName)
-    if module is None:
-        module = sys.modules[packageName] = types.ModuleType(packageName)
-        module.__path__ = []
-        _set_parent_ns(packageName)
+    if loader is None: 
+        return None 
+    module = sys.modules.get(packageName) 
+    if module is None: 
+        module = sys.modules[packageName] = types.ModuleType(packageName) 
+        module.__path__ = [] 
+        _set_parent_ns(packageName) 
     elif not hasattr(module, '__path__'):
-        raise TypeError("Not a package:", packageName)
-    handler = _find_adapter(_namespace_handlers, importer)
-    subpath = handler(importer, path_item, packageName, module)
-    if subpath is not None:
-        path = module.__path__
-        path.append(subpath)
-        loader.load_module(packageName)
-        _rebuild_mod_path(path, packageName, module)
-    return subpath
-
-
-def _rebuild_mod_path(orig_path, package_name, module):
-    """
-    Rebuild module.__path__ ensuring that all entries are ordered
-    corresponding to their sys.path order
-    """
-    sys_path = [_normalize_cached(p) for p in sys.path]
+        raise TypeError("Not a package:", packageName) 
+    handler = _find_adapter(_namespace_handlers, importer) 
+    subpath = handler(importer, path_item, packageName, module) 
+    if subpath is not None: 
+        path = module.__path__ 
+        path.append(subpath) 
+        loader.load_module(packageName) 
+        _rebuild_mod_path(path, packageName, module) 
+    return subpath 
+ 
+ 
+def _rebuild_mod_path(orig_path, package_name, module): 
+    """ 
+    Rebuild module.__path__ ensuring that all entries are ordered 
+    corresponding to their sys.path order 
+    """ 
+    sys_path = [_normalize_cached(p) for p in sys.path] 
 
     def safe_sys_path_index(entry):
-        """
+        """ 
         Workaround for #520 and #513.
         """
         try:
@@ -2237,13 +2237,13 @@ def _rebuild_mod_path(orig_path, package_name, module):
 
     def position_in_sys_path(path):
         """
-        Return the ordinal of the path based on its position in sys.path
-        """
+        Return the ordinal of the path based on its position in sys.path 
+        """ 
         path_parts = path.split(os.sep)
         module_parts = package_name.count('.') + 1
         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]
 
@@ -2251,85 +2251,85 @@ def _rebuild_mod_path(orig_path, package_name, module):
         module.__path__[:] = new_path
     else:
         module.__path__ = new_path
-
-
-def declare_namespace(packageName):
-    """Declare that package 'packageName' is a namespace package"""
-
-    _imp.acquire_lock()
-    try:
-        if packageName in _namespace_packages:
-            return
-
+ 
+ 
+def declare_namespace(packageName): 
+    """Declare that package 'packageName' is a namespace package""" 
+ 
+    _imp.acquire_lock() 
+    try: 
+        if packageName in _namespace_packages: 
+            return 
+ 
         path = sys.path
         parent, _, _ = packageName.rpartition('.')
 
         if parent:
-            declare_namespace(parent)
-            if parent not in _namespace_packages:
-                __import__(parent)
-            try:
-                path = sys.modules[parent].__path__
-            except AttributeError:
-                raise TypeError("Not a package:", parent)
-
-        # Track what packages are namespaces, so when new path items are added,
-        # they can be updated
+            declare_namespace(parent) 
+            if parent not in _namespace_packages: 
+                __import__(parent) 
+            try: 
+                path = sys.modules[parent].__path__ 
+            except AttributeError: 
+                raise TypeError("Not a package:", parent) 
+ 
+        # 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(packageName, [])
-
-        for path_item in path:
-            # Ensure all the parent's path items are reflected in the child,
-            # if they apply
-            _handle_ns(packageName, path_item)
-
-    finally:
-        _imp.release_lock()
-
-
-def fixup_namespace_packages(path_item, parent=None):
-    """Ensure that previously-declared namespace packages include path_item"""
-    _imp.acquire_lock()
-    try:
+ 
+        for path_item in path: 
+            # Ensure all the parent's path items are reflected in the child, 
+            # if they apply 
+            _handle_ns(packageName, path_item) 
+ 
+    finally: 
+        _imp.release_lock() 
+ 
+
+def fixup_namespace_packages(path_item, parent=None): 
+    """Ensure that previously-declared namespace packages include path_item""" 
+    _imp.acquire_lock() 
+    try: 
         for package in _namespace_packages.get(parent, ()):
-            subpath = _handle_ns(package, path_item)
-            if subpath:
-                fixup_namespace_packages(subpath, package)
-    finally:
-        _imp.release_lock()
-
-
-def file_ns_handler(importer, path_item, packageName, module):
-    """Compute an ns-package subpath for a filesystem or zipfile importer"""
-
-    subpath = os.path.join(path_item, packageName.split('.')[-1])
-    normalized = _normalize_cached(subpath)
-    for item in module.__path__:
+            subpath = _handle_ns(package, path_item) 
+            if subpath: 
+                fixup_namespace_packages(subpath, package) 
+    finally: 
+        _imp.release_lock() 
+ 
+
+def file_ns_handler(importer, path_item, packageName, module): 
+    """Compute an ns-package subpath for a filesystem or zipfile importer""" 
+ 
+    subpath = os.path.join(path_item, packageName.split('.')[-1]) 
+    normalized = _normalize_cached(subpath) 
+    for item in module.__path__: 
         if _normalize_cached(item) == normalized:
-            break
-    else:
-        # Only return the path if it's not already there
-        return subpath
-
-
-register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
-register_namespace_handler(zipimport.zipimporter, file_ns_handler)
-
-if hasattr(importlib_machinery, 'FileFinder'):
-    register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler)
-
-
-def null_ns_handler(importer, path_item, packageName, module):
-    return None
-
-
-register_namespace_handler(object, null_ns_handler)
-
-
-def normalize_path(filename):
-    """Normalize a file/dir name for comparison purposes"""
+            break 
+    else: 
+        # Only return the path if it's not already there 
+        return subpath 
+ 
+
+register_namespace_handler(pkgutil.ImpImporter, file_ns_handler) 
+register_namespace_handler(zipimport.zipimporter, file_ns_handler) 
+ 
+if hasattr(importlib_machinery, 'FileFinder'): 
+    register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler) 
+ 
+ 
+def null_ns_handler(importer, path_item, packageName, module): 
+    return None 
+ 
+
+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
     """
@@ -2342,13 +2342,13 @@ def _cygwin_patch(filename):  # pragma: nocover
     return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
 
 
-def _normalize_cached(filename, _cache={}):
-    try:
-        return _cache[filename]
-    except KeyError:
-        _cache[filename] = result = normalize_path(filename)
-        return result
-
+def _normalize_cached(filename, _cache={}): 
+    try: 
+        return _cache[filename] 
+    except KeyError: 
+        _cache[filename] = result = normalize_path(filename) 
+        return result 
+ 
 
 def _is_egg_path(path):
     """
@@ -2357,351 +2357,351 @@ def _is_egg_path(path):
     return path.lower().endswith('.egg')
 
 
-def _is_unpacked_egg(path):
-    """
-    Determine if given path appears to be an unpacked egg.
-    """
-    return (
+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'))
-    )
-
-
-def _set_parent_ns(packageName):
-    parts = packageName.split('.')
-    name = parts.pop()
-    if parts:
-        parent = '.'.join(parts)
-        setattr(sys.modules[parent], name, sys.modules[packageName])
-
-
-def yield_lines(strs):
-    """Yield non-empty/non-comment lines of a string or sequence"""
-    if isinstance(strs, six.string_types):
-        for s in strs.splitlines():
-            s = s.strip()
-            # skip blank lines/comments
-            if s and not s.startswith('#'):
-                yield s
-    else:
-        for ss in strs:
-            for s in yield_lines(ss):
-                yield s
-
-
-MODULE = re.compile(r"\w+(\.\w+)*$").match
-EGG_NAME = re.compile(
-    r"""
-    (?P<name>[^-]+) (
-        -(?P<ver>[^-]+) (
-            -py(?P<pyver>[^-]+) (
-                -(?P<plat>.+)
-            )?
-        )?
-    )?
-    """,
-    re.VERBOSE | re.IGNORECASE,
-).match
-
-
+    ) 
+ 
+
+def _set_parent_ns(packageName): 
+    parts = packageName.split('.') 
+    name = parts.pop() 
+    if parts: 
+        parent = '.'.join(parts) 
+        setattr(sys.modules[parent], name, sys.modules[packageName]) 
+ 
+ 
+def yield_lines(strs): 
+    """Yield non-empty/non-comment lines of a string or sequence""" 
+    if isinstance(strs, six.string_types): 
+        for s in strs.splitlines(): 
+            s = s.strip() 
+            # skip blank lines/comments 
+            if s and not s.startswith('#'): 
+                yield s 
+    else: 
+        for ss in strs: 
+            for s in yield_lines(ss): 
+                yield s 
+ 
+
+MODULE = re.compile(r"\w+(\.\w+)*$").match 
+EGG_NAME = re.compile( 
+    r""" 
+    (?P<name>[^-]+) ( 
+        -(?P<ver>[^-]+) ( 
+            -py(?P<pyver>[^-]+) ( 
+                -(?P<plat>.+) 
+            )? 
+        )? 
+    )? 
+    """, 
+    re.VERBOSE | re.IGNORECASE, 
+).match 
+ 
+ 
 class EntryPoint:
-    """Object representing an advertised importable object"""
-
-    def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
-        if not MODULE(module_name):
-            raise ValueError("Invalid module name", module_name)
-        self.name = name
-        self.module_name = module_name
-        self.attrs = tuple(attrs)
+    """Object representing an advertised importable object""" 
+ 
+    def __init__(self, name, module_name, attrs=(), extras=(), dist=None): 
+        if not MODULE(module_name): 
+            raise ValueError("Invalid module name", module_name) 
+        self.name = name 
+        self.module_name = module_name 
+        self.attrs = tuple(attrs) 
         self.extras = tuple(extras)
-        self.dist = dist
-
-    def __str__(self):
-        s = "%s = %s" % (self.name, self.module_name)
-        if self.attrs:
-            s += ':' + '.'.join(self.attrs)
-        if self.extras:
-            s += ' [%s]' % ','.join(self.extras)
-        return s
-
-    def __repr__(self):
-        return "EntryPoint.parse(%r)" % str(self)
-
-    def load(self, require=True, *args, **kwargs):
-        """
-        Require packages for this EntryPoint, then resolve it.
-        """
-        if not require or args or kwargs:
-            warnings.warn(
-                "Parameters to load are deprecated.  Call .resolve and "
-                ".require separately.",
+        self.dist = dist 
+ 
+    def __str__(self): 
+        s = "%s = %s" % (self.name, self.module_name) 
+        if self.attrs: 
+            s += ':' + '.'.join(self.attrs) 
+        if self.extras: 
+            s += ' [%s]' % ','.join(self.extras) 
+        return s 
+ 
+    def __repr__(self): 
+        return "EntryPoint.parse(%r)" % str(self) 
+ 
+    def load(self, require=True, *args, **kwargs): 
+        """ 
+        Require packages for this EntryPoint, then resolve it. 
+        """ 
+        if not require or args or kwargs: 
+            warnings.warn( 
+                "Parameters to load are deprecated.  Call .resolve and " 
+                ".require separately.", 
                 PkgResourcesDeprecationWarning,
-                stacklevel=2,
-            )
-        if require:
-            self.require(*args, **kwargs)
-        return self.resolve()
-
-    def resolve(self):
-        """
-        Resolve the entry point from its module and attrs.
-        """
-        module = __import__(self.module_name, fromlist=['__name__'], level=0)
-        try:
-            return functools.reduce(getattr, self.attrs, module)
-        except AttributeError as exc:
-            raise ImportError(str(exc))
-
-    def require(self, env=None, installer=None):
-        if self.extras and not self.dist:
-            raise UnknownExtra("Can't require() without a distribution", self)
+                stacklevel=2, 
+            ) 
+        if require: 
+            self.require(*args, **kwargs) 
+        return self.resolve() 
+ 
+    def resolve(self): 
+        """ 
+        Resolve the entry point from its module and attrs. 
+        """ 
+        module = __import__(self.module_name, fromlist=['__name__'], level=0) 
+        try: 
+            return functools.reduce(getattr, self.attrs, module) 
+        except AttributeError as exc: 
+            raise ImportError(str(exc)) 
+ 
+    def require(self, env=None, installer=None): 
+        if self.extras and not self.dist: 
+            raise UnknownExtra("Can't require() without a distribution", self) 
 
         # Get the requirements for this entry point with all its extras and
         # then resolve them. We have to pass `extras` along when resolving so
         # that the working set knows what extras we want. Otherwise, for
         # dist-info distributions, the working set will assume that the
         # requirements for that extra are purely optional and skip over them.
-        reqs = self.dist.requires(self.extras)
+        reqs = self.dist.requires(self.extras) 
         items = working_set.resolve(reqs, env, installer, extras=self.extras)
-        list(map(working_set.add, items))
-
-    pattern = re.compile(
-        r'\s*'
-        r'(?P<name>.+?)\s*'
-        r'=\s*'
-        r'(?P<module>[\w.]+)\s*'
-        r'(:\s*(?P<attr>[\w.]+))?\s*'
-        r'(?P<extras>\[.*\])?\s*$'
-    )
-
-    @classmethod
-    def parse(cls, src, dist=None):
-        """Parse a single entry point from string `src`
-
-        Entry point syntax follows the form::
-
-            name = some.module:some.attr [extra1, extra2]
-
-        The entry name and module name are required, but the ``:attrs`` and
-        ``[extras]`` parts are optional
-        """
-        m = cls.pattern.match(src)
-        if not m:
-            msg = "EntryPoint must be in 'name=module:attrs [extras]' format"
-            raise ValueError(msg, src)
-        res = m.groupdict()
-        extras = cls._parse_extras(res['extras'])
-        attrs = res['attr'].split('.') if res['attr'] else ()
-        return cls(res['name'], res['module'], attrs, extras, dist)
-
-    @classmethod
-    def _parse_extras(cls, extras_spec):
-        if not extras_spec:
-            return ()
-        req = Requirement.parse('x' + extras_spec)
-        if req.specs:
-            raise ValueError()
-        return req.extras
-
-    @classmethod
-    def parse_group(cls, group, lines, dist=None):
-        """Parse an entry point group"""
-        if not MODULE(group):
-            raise ValueError("Invalid group name", group)
-        this = {}
-        for line in yield_lines(lines):
-            ep = cls.parse(line, dist)
-            if ep.name in this:
-                raise ValueError("Duplicate entry point", group, ep.name)
+        list(map(working_set.add, items)) 
+ 
+    pattern = re.compile( 
+        r'\s*' 
+        r'(?P<name>.+?)\s*' 
+        r'=\s*' 
+        r'(?P<module>[\w.]+)\s*' 
+        r'(:\s*(?P<attr>[\w.]+))?\s*' 
+        r'(?P<extras>\[.*\])?\s*$' 
+    ) 
+ 
+    @classmethod 
+    def parse(cls, src, dist=None): 
+        """Parse a single entry point from string `src` 
+ 
+        Entry point syntax follows the form:: 
+ 
+            name = some.module:some.attr [extra1, extra2] 
+ 
+        The entry name and module name are required, but the ``:attrs`` and 
+        ``[extras]`` parts are optional 
+        """ 
+        m = cls.pattern.match(src) 
+        if not m: 
+            msg = "EntryPoint must be in 'name=module:attrs [extras]' format" 
+            raise ValueError(msg, src) 
+        res = m.groupdict() 
+        extras = cls._parse_extras(res['extras']) 
+        attrs = res['attr'].split('.') if res['attr'] else () 
+        return cls(res['name'], res['module'], attrs, extras, dist) 
+ 
+    @classmethod 
+    def _parse_extras(cls, extras_spec): 
+        if not extras_spec: 
+            return () 
+        req = Requirement.parse('x' + extras_spec) 
+        if req.specs: 
+            raise ValueError() 
+        return req.extras 
+ 
+    @classmethod 
+    def parse_group(cls, group, lines, dist=None): 
+        """Parse an entry point group""" 
+        if not MODULE(group): 
+            raise ValueError("Invalid group name", group) 
+        this = {} 
+        for line in yield_lines(lines): 
+            ep = cls.parse(line, dist) 
+            if ep.name in this: 
+                raise ValueError("Duplicate entry point", group, ep.name) 
             this[ep.name] = ep
-        return this
-
-    @classmethod
-    def parse_map(cls, data, dist=None):
-        """Parse a map of entry point groups"""
-        if isinstance(data, dict):
-            data = data.items()
-        else:
-            data = split_sections(data)
-        maps = {}
-        for group, lines in data:
-            if group is None:
-                if not lines:
-                    continue
-                raise ValueError("Entry points must be listed in groups")
-            group = group.strip()
-            if group in maps:
-                raise ValueError("Duplicate group name", group)
-            maps[group] = cls.parse_group(group, lines, dist)
-        return maps
-
-
-def _remove_md5_fragment(location):
-    if not location:
-        return ''
-    parsed = urllib.parse.urlparse(location)
-    if parsed[-1].startswith('md5='):
-        return urllib.parse.urlunparse(parsed[:-1] + ('',))
-    return location
-
-
-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.
-    """
+        return this 
+ 
+    @classmethod 
+    def parse_map(cls, data, dist=None): 
+        """Parse a map of entry point groups""" 
+        if isinstance(data, dict): 
+            data = data.items() 
+        else: 
+            data = split_sections(data) 
+        maps = {} 
+        for group, lines in data: 
+            if group is None: 
+                if not lines: 
+                    continue 
+                raise ValueError("Entry points must be listed in groups") 
+            group = group.strip() 
+            if group in maps: 
+                raise ValueError("Duplicate group name", group) 
+            maps[group] = cls.parse_group(group, lines, dist) 
+        return maps 
+ 
+ 
+def _remove_md5_fragment(location): 
+    if not location: 
+        return '' 
+    parsed = urllib.parse.urlparse(location) 
+    if parsed[-1].startswith('md5='): 
+        return urllib.parse.urlunparse(parsed[:-1] + ('',)) 
+    return location 
+ 
+ 
+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:')
-    version_lines = filter(is_version_line, lines)
-    line = next(iter(version_lines), '')
-    _, _, value = line.partition(':')
-    return safe_version(value.strip()) or None
-
-
+    version_lines = filter(is_version_line, lines) 
+    line = next(iter(version_lines), '') 
+    _, _, value = line.partition(':') 
+    return safe_version(value.strip()) or None 
+ 
+ 
 class Distribution:
-    """Wrap an actual or potential sys.path entry w/metadata"""
-    PKG_INFO = 'PKG-INFO'
-
+    """Wrap an actual or potential sys.path entry w/metadata""" 
+    PKG_INFO = 'PKG-INFO' 
+ 
     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')
-        if version is not None:
-            self._version = safe_version(version)
-        self.py_version = py_version
-        self.platform = platform
-        self.location = location
-        self.precedence = precedence
-        self._provider = metadata or empty_provider
-
-    @classmethod
-    def from_location(cls, location, basename, metadata=None, **kw):
+            version=None, py_version=PY_MAJOR, platform=None, 
+            precedence=EGG_DIST): 
+        self.project_name = safe_name(project_name or 'Unknown') 
+        if version is not None: 
+            self._version = safe_version(version) 
+        self.py_version = py_version 
+        self.platform = platform 
+        self.location = location 
+        self.precedence = precedence 
+        self._provider = metadata or empty_provider 
+ 
+    @classmethod 
+    def from_location(cls, location, basename, metadata=None, **kw): 
         project_name, version, py_version, platform = [None] * 4
-        basename, ext = os.path.splitext(basename)
-        if ext.lower() in _distributionImpl:
-            cls = _distributionImpl[ext.lower()]
-
-            match = EGG_NAME(basename)
-            if match:
-                project_name, version, py_version, platform = match.group(
-                    'name', 'ver', 'pyver', 'plat'
-                )
-        return cls(
-            location, metadata, project_name=project_name, version=version,
-            py_version=py_version, platform=platform, **kw
-        )._reload_version()
-
-    def _reload_version(self):
-        return self
-
-    @property
-    def hashcmp(self):
-        return (
-            self.parsed_version,
-            self.precedence,
-            self.key,
-            _remove_md5_fragment(self.location),
-            self.py_version or '',
-            self.platform or '',
-        )
-
-    def __hash__(self):
-        return hash(self.hashcmp)
-
-    def __lt__(self, other):
-        return self.hashcmp < other.hashcmp
-
-    def __le__(self, other):
-        return self.hashcmp <= other.hashcmp
-
-    def __gt__(self, other):
-        return self.hashcmp > other.hashcmp
-
-    def __ge__(self, other):
-        return self.hashcmp >= other.hashcmp
-
-    def __eq__(self, other):
-        if not isinstance(other, self.__class__):
-            # It's not a Distribution, so they are not equal
-            return False
-        return self.hashcmp == other.hashcmp
-
-    def __ne__(self, other):
-        return not self == other
-
-    # These properties have to be lazy so that we don't have to load any
-    # metadata until/unless it's actually needed.  (i.e., some distributions
-    # may not know their name or version without loading PKG-INFO)
-
-    @property
-    def key(self):
-        try:
-            return self._key
-        except AttributeError:
-            self._key = key = self.project_name.lower()
-            return key
-
-    @property
-    def parsed_version(self):
-        if not hasattr(self, "_parsed_version"):
-            self._parsed_version = parse_version(self.version)
-
-        return self._parsed_version
-
-    def _warn_legacy_version(self):
-        LV = packaging.version.LegacyVersion
-        is_legacy = isinstance(self._parsed_version, LV)
-        if not is_legacy:
-            return
-
-        # While an empty version is technically a legacy version and
-        # is not a valid PEP 440 version, it's also unlikely to
-        # actually come from someone and instead it is more likely that
-        # it comes from setuptools attempting to parse a filename and
-        # including it in the list. So for that we'll gate this warning
-        # on if the version is anything at all or not.
-        if not self.version:
-            return
-
-        tmpl = textwrap.dedent("""
-            '{project_name} ({version})' is being parsed as a legacy,
-            non PEP 440,
-            version. You may find odd behavior and sort order.
-            In particular it will be sorted as less than 0.0. It
-            is recommended to migrate to PEP 440 compatible
-            versions.
-            """).strip().replace('\n', ' ')
-
-        warnings.warn(tmpl.format(**vars(self)), PEP440Warning)
-
-    @property
-    def version(self):
-        try:
-            return self._version
-        except AttributeError:
+        basename, ext = os.path.splitext(basename) 
+        if ext.lower() in _distributionImpl: 
+            cls = _distributionImpl[ext.lower()] 
+ 
+            match = EGG_NAME(basename) 
+            if match: 
+                project_name, version, py_version, platform = match.group( 
+                    'name', 'ver', 'pyver', 'plat' 
+                ) 
+        return cls( 
+            location, metadata, project_name=project_name, version=version, 
+            py_version=py_version, platform=platform, **kw 
+        )._reload_version() 
+ 
+    def _reload_version(self): 
+        return self 
+ 
+    @property 
+    def hashcmp(self): 
+        return ( 
+            self.parsed_version, 
+            self.precedence, 
+            self.key, 
+            _remove_md5_fragment(self.location), 
+            self.py_version or '', 
+            self.platform or '', 
+        ) 
+ 
+    def __hash__(self): 
+        return hash(self.hashcmp) 
+ 
+    def __lt__(self, other): 
+        return self.hashcmp < other.hashcmp 
+ 
+    def __le__(self, other): 
+        return self.hashcmp <= other.hashcmp 
+ 
+    def __gt__(self, other): 
+        return self.hashcmp > other.hashcmp 
+ 
+    def __ge__(self, other): 
+        return self.hashcmp >= other.hashcmp 
+ 
+    def __eq__(self, other): 
+        if not isinstance(other, self.__class__): 
+            # It's not a Distribution, so they are not equal 
+            return False 
+        return self.hashcmp == other.hashcmp 
+ 
+    def __ne__(self, other): 
+        return not self == other 
+ 
+    # These properties have to be lazy so that we don't have to load any 
+    # metadata until/unless it's actually needed.  (i.e., some distributions 
+    # may not know their name or version without loading PKG-INFO) 
+ 
+    @property 
+    def key(self): 
+        try: 
+            return self._key 
+        except AttributeError: 
+            self._key = key = self.project_name.lower() 
+            return key 
+ 
+    @property 
+    def parsed_version(self): 
+        if not hasattr(self, "_parsed_version"): 
+            self._parsed_version = parse_version(self.version) 
+ 
+        return self._parsed_version 
+ 
+    def _warn_legacy_version(self): 
+        LV = packaging.version.LegacyVersion 
+        is_legacy = isinstance(self._parsed_version, LV) 
+        if not is_legacy: 
+            return 
+ 
+        # While an empty version is technically a legacy version and 
+        # is not a valid PEP 440 version, it's also unlikely to 
+        # actually come from someone and instead it is more likely that 
+        # it comes from setuptools attempting to parse a filename and 
+        # including it in the list. So for that we'll gate this warning 
+        # on if the version is anything at all or not. 
+        if not self.version: 
+            return 
+ 
+        tmpl = textwrap.dedent(""" 
+            '{project_name} ({version})' is being parsed as a legacy, 
+            non PEP 440, 
+            version. You may find odd behavior and sort order. 
+            In particular it will be sorted as less than 0.0. It 
+            is recommended to migrate to PEP 440 compatible 
+            versions. 
+            """).strip().replace('\n', ' ') 
+ 
+        warnings.warn(tmpl.format(**vars(self)), PEP440Warning) 
+ 
+    @property 
+    def version(self): 
+        try: 
+            return self._version 
+        except AttributeError: 
             version = self._get_version()
-            if version is None:
+            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)
 
-            return version
-
-    @property
-    def _dep_map(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.
         """
-        try:
-            return self.__dep_map
-        except AttributeError:
+        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):
         """
@@ -2731,20 +2731,20 @@ class Distribution:
                 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
-        deps = []
-        deps.extend(dm.get(None, ()))
-        for ext in extras:
-            try:
-                deps.extend(dm[safe_extra(ext)])
-            except KeyError:
-                raise UnknownExtra(
-                    "%s has no such extra feature %r" % (self, ext)
-                )
-        return deps
-
+    def requires(self, extras=()): 
+        """List of Requirements needed for this distro if `extras` are used""" 
+        dm = self._dep_map 
+        deps = [] 
+        deps.extend(dm.get(None, ())) 
+        for ext in extras: 
+            try: 
+                deps.extend(dm[safe_extra(ext)]) 
+            except KeyError: 
+                raise UnknownExtra( 
+                    "%s has no such extra feature %r" % (self, ext) 
+                ) 
+        return deps 
+ 
     def _get_metadata_path_for_display(self, name):
         """
         Return the path to the given metadata file, if available.
@@ -2762,11 +2762,11 @@ class Distribution:
 
         return path
 
-    def _get_metadata(self, name):
-        if self.has_metadata(name):
-            for line in self.get_metadata_lines(name):
-                yield line
-
+    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)
@@ -2774,47 +2774,47 @@ class Distribution:
         return version
 
     def activate(self, path=None, replace=False):
-        """Ensure distribution is importable on `path` (default=sys.path)"""
-        if path is None:
-            path = sys.path
+        """Ensure distribution is importable on `path` (default=sys.path)""" 
+        if path is None: 
+            path = sys.path 
         self.insert_on(path, replace=replace)
-        if path is sys.path:
-            fixup_namespace_packages(self.location)
-            for pkg in self._get_metadata('namespace_packages.txt'):
-                if pkg in sys.modules:
-                    declare_namespace(pkg)
-
-    def egg_name(self):
-        """Return what this distribution's standard .egg filename should be"""
-        filename = "%s-%s-py%s" % (
-            to_filename(self.project_name), to_filename(self.version),
-            self.py_version or PY_MAJOR
-        )
-
-        if self.platform:
-            filename += '-' + self.platform
-        return filename
-
-    def __repr__(self):
-        if self.location:
-            return "%s (%s)" % (self, self.location)
-        else:
-            return str(self)
-
-    def __str__(self):
-        try:
-            version = getattr(self, 'version', None)
-        except ValueError:
-            version = None
-        version = version or "[unknown version]"
-        return "%s %s" % (self.project_name, version)
-
-    def __getattr__(self, attr):
-        """Delegate all unrecognized public attributes to .metadata provider"""
-        if attr.startswith('_'):
-            raise AttributeError(attr)
-        return getattr(self._provider, attr)
-
+        if path is sys.path: 
+            fixup_namespace_packages(self.location) 
+            for pkg in self._get_metadata('namespace_packages.txt'): 
+                if pkg in sys.modules: 
+                    declare_namespace(pkg) 
+ 
+    def egg_name(self): 
+        """Return what this distribution's standard .egg filename should be""" 
+        filename = "%s-%s-py%s" % ( 
+            to_filename(self.project_name), to_filename(self.version), 
+            self.py_version or PY_MAJOR 
+        ) 
+ 
+        if self.platform: 
+            filename += '-' + self.platform 
+        return filename 
+ 
+    def __repr__(self): 
+        if self.location: 
+            return "%s (%s)" % (self, self.location) 
+        else: 
+            return str(self) 
+ 
+    def __str__(self): 
+        try: 
+            version = getattr(self, 'version', None) 
+        except ValueError: 
+            version = None 
+        version = version or "[unknown version]" 
+        return "%s %s" % (self.project_name, version) 
+ 
+    def __getattr__(self, attr): 
+        """Delegate all unrecognized public attributes to .metadata provider""" 
+        if attr.startswith('_'): 
+            raise AttributeError(attr) 
+        return getattr(self._provider, attr) 
+ 
     def __dir__(self):
         return list(
             set(super(Distribution, self).__dir__())
@@ -2828,48 +2828,48 @@ class Distribution:
         # python 2.7 not supported
         del __dir__
 
-    @classmethod
-    def from_filename(cls, filename, metadata=None, **kw):
-        return cls.from_location(
-            _normalize_cached(filename), os.path.basename(filename), metadata,
-            **kw
-        )
-
-    def as_requirement(self):
-        """Return a ``Requirement`` that matches this distribution exactly"""
-        if isinstance(self.parsed_version, packaging.version.Version):
-            spec = "%s==%s" % (self.project_name, self.parsed_version)
-        else:
-            spec = "%s===%s" % (self.project_name, self.parsed_version)
-
-        return Requirement.parse(spec)
-
-    def load_entry_point(self, group, name):
-        """Return the `name` entry point of `group` or raise ImportError"""
-        ep = self.get_entry_info(group, name)
-        if ep is None:
-            raise ImportError("Entry point %r not found" % ((group, name),))
-        return ep.load()
-
-    def get_entry_map(self, group=None):
-        """Return the entry point map for `group`, or the full entry map"""
-        try:
-            ep_map = self._ep_map
-        except AttributeError:
-            ep_map = self._ep_map = EntryPoint.parse_map(
-                self._get_metadata('entry_points.txt'), self
-            )
-        if group is not None:
+    @classmethod 
+    def from_filename(cls, filename, metadata=None, **kw): 
+        return cls.from_location( 
+            _normalize_cached(filename), os.path.basename(filename), metadata, 
+            **kw 
+        ) 
+ 
+    def as_requirement(self): 
+        """Return a ``Requirement`` that matches this distribution exactly""" 
+        if isinstance(self.parsed_version, packaging.version.Version): 
+            spec = "%s==%s" % (self.project_name, self.parsed_version) 
+        else: 
+            spec = "%s===%s" % (self.project_name, self.parsed_version) 
+ 
+        return Requirement.parse(spec) 
+ 
+    def load_entry_point(self, group, name): 
+        """Return the `name` entry point of `group` or raise ImportError""" 
+        ep = self.get_entry_info(group, name) 
+        if ep is None: 
+            raise ImportError("Entry point %r not found" % ((group, name),)) 
+        return ep.load() 
+ 
+    def get_entry_map(self, group=None): 
+        """Return the entry point map for `group`, or the full entry map""" 
+        try: 
+            ep_map = self._ep_map 
+        except AttributeError: 
+            ep_map = self._ep_map = EntryPoint.parse_map( 
+                self._get_metadata('entry_points.txt'), self 
+            ) 
+        if group is not None: 
             return ep_map.get(group, {})
-        return ep_map
-
-    def get_entry_info(self, group, name):
-        """Return the EntryPoint object for `group`+`name`, or ``None``"""
-        return self.get_entry_map(group).get(name)
-
-    def insert_on(self, path, loc=None, replace=False):
+        return ep_map 
+ 
+    def get_entry_info(self, group, name): 
+        """Return the EntryPoint object for `group`+`name`, or ``None``""" 
+        return self.get_entry_map(group).get(name) 
+ 
+    def insert_on(self, path, loc=None, replace=False): 
         """Ensure self.location is on path
-
+ 
         If replace=False (default):
             - If location is already in path anywhere, do nothing.
             - Else:
@@ -2887,200 +2887,200 @@ class Distribution:
               - Else: add it to the front of path.
         """
 
-        loc = loc or self.location
-        if not loc:
-            return
-
-        nloc = _normalize_cached(loc)
-        bdir = os.path.dirname(nloc)
+        loc = loc or self.location 
+        if not loc: 
+            return 
+ 
+        nloc = _normalize_cached(loc) 
+        bdir = os.path.dirname(nloc) 
         npath = [(p and _normalize_cached(p) or p) for p in path]
-
-        for p, item in enumerate(npath):
-            if item == nloc:
+ 
+        for p, item in enumerate(npath): 
+            if item == nloc: 
                 if replace:
                     break
                 else:
                     # 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
+            elif item == bdir and self.precedence == EGG_DIST: 
+                # if it's an .egg, give it precedence over its directory 
                 # UNLESS it's already been added to sys.path and replace=False
                 if (not replace) and nloc in npath[p:]:
                     return
-                if path is sys.path:
-                    self.check_version_conflict()
-                path.insert(p, loc)
-                npath.insert(p, nloc)
-                break
-        else:
-            if path is sys.path:
-                self.check_version_conflict()
-            if replace:
-                path.insert(0, loc)
-            else:
-                path.append(loc)
-            return
-
-        # p is the spot where we found or inserted loc; now remove duplicates
-        while True:
-            try:
+                if path is sys.path: 
+                    self.check_version_conflict() 
+                path.insert(p, loc) 
+                npath.insert(p, nloc) 
+                break 
+        else: 
+            if path is sys.path: 
+                self.check_version_conflict() 
+            if replace: 
+                path.insert(0, loc) 
+            else: 
+                path.append(loc) 
+            return 
+ 
+        # p is the spot where we found or inserted loc; now remove duplicates 
+        while True: 
+            try: 
                 np = npath.index(nloc, p + 1)
-            except ValueError:
-                break
-            else:
-                del npath[np], path[np]
-                # ha!
-                p = np
-
-        return
-
-    def check_version_conflict(self):
-        if self.key == 'setuptools':
-            # ignore the inevitable setuptools self-conflicts  :(
-            return
-
-        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
-        loc = normalize_path(self.location)
-        for modname in self._get_metadata('top_level.txt'):
-            if (modname not in sys.modules or modname in nsp
-                    or modname in _namespace_packages):
-                continue
-            if modname in ('pkg_resources', 'setuptools', 'site'):
-                continue
-            fn = getattr(sys.modules[modname], '__file__', None)
-            if fn and (normalize_path(fn).startswith(loc) or
-                       fn.startswith(self.location)):
-                continue
-            issue_warning(
-                "Module %s was already imported from %s, but %s is being added"
-                " to sys.path" % (modname, fn, self.location),
-            )
-
-    def has_version(self):
-        try:
-            self.version
-        except ValueError:
-            issue_warning("Unbuilt egg for " + repr(self))
-            return False
-        return True
-
+            except ValueError: 
+                break 
+            else: 
+                del npath[np], path[np] 
+                # ha! 
+                p = np 
+ 
+        return 
+ 
+    def check_version_conflict(self): 
+        if self.key == 'setuptools': 
+            # ignore the inevitable setuptools self-conflicts  :( 
+            return 
+ 
+        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt')) 
+        loc = normalize_path(self.location) 
+        for modname in self._get_metadata('top_level.txt'): 
+            if (modname not in sys.modules or modname in nsp 
+                    or modname in _namespace_packages): 
+                continue 
+            if modname in ('pkg_resources', 'setuptools', 'site'): 
+                continue 
+            fn = getattr(sys.modules[modname], '__file__', None) 
+            if fn and (normalize_path(fn).startswith(loc) or 
+                       fn.startswith(self.location)): 
+                continue 
+            issue_warning( 
+                "Module %s was already imported from %s, but %s is being added" 
+                " to sys.path" % (modname, fn, self.location), 
+            ) 
+ 
+    def has_version(self): 
+        try: 
+            self.version 
+        except ValueError: 
+            issue_warning("Unbuilt egg for " + repr(self)) 
+            return False 
+        return True 
+ 
     def clone(self, **kw):
-        """Copy this distribution, substituting in any changed keyword args"""
-        names = 'project_name version py_version platform location precedence'
-        for attr in names.split():
-            kw.setdefault(attr, getattr(self, attr, None))
-        kw.setdefault('metadata', self._provider)
-        return self.__class__(**kw)
-
-    @property
-    def extras(self):
-        return [dep for dep in self._dep_map if dep]
-
-
-class EggInfoDistribution(Distribution):
-    def _reload_version(self):
-        """
-        Packages installed by distutils (e.g. numpy or scipy),
-        which uses an old safe_version, and so
-        their version numbers can get mangled when
-        converted to filenames (e.g., 1.11.0.dev0+2329eae to
-        1.11.0.dev0_2329eae). These distributions will not be
-        parsed properly
-        downstream by Distribution and safe_version, so
-        take an extra step and try to get the version number from
-        the metadata file itself instead of the filename.
-        """
+        """Copy this distribution, substituting in any changed keyword args""" 
+        names = 'project_name version py_version platform location precedence' 
+        for attr in names.split(): 
+            kw.setdefault(attr, getattr(self, attr, None)) 
+        kw.setdefault('metadata', self._provider) 
+        return self.__class__(**kw) 
+ 
+    @property 
+    def extras(self): 
+        return [dep for dep in self._dep_map if dep] 
+ 
+ 
+class EggInfoDistribution(Distribution): 
+    def _reload_version(self): 
+        """ 
+        Packages installed by distutils (e.g. numpy or scipy), 
+        which uses an old safe_version, and so 
+        their version numbers can get mangled when 
+        converted to filenames (e.g., 1.11.0.dev0+2329eae to 
+        1.11.0.dev0_2329eae). These distributions will not be 
+        parsed properly 
+        downstream by Distribution and safe_version, so 
+        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()
-        if md_version:
-            self._version = md_version
-        return self
-
-
-class DistInfoDistribution(Distribution):
+        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.
     """
-    PKG_INFO = 'METADATA'
-    EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
-
-    @property
-    def _parsed_pkg_info(self):
-        """Parse and cache metadata"""
-        try:
-            return self._pkg_info
-        except AttributeError:
-            metadata = self.get_metadata(self.PKG_INFO)
-            self._pkg_info = email.parser.Parser().parsestr(metadata)
-            return self._pkg_info
-
-    @property
-    def _dep_map(self):
-        try:
-            return self.__dep_map
-        except AttributeError:
-            self.__dep_map = self._compute_dependencies()
-            return self.__dep_map
-
-    def _compute_dependencies(self):
-        """Recompute this distribution's dependencies."""
-        dm = self.__dep_map = {None: []}
-
-        reqs = []
-        # Including any condition expressions
-        for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
+    PKG_INFO = 'METADATA' 
+    EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])") 
+ 
+    @property 
+    def _parsed_pkg_info(self): 
+        """Parse and cache metadata""" 
+        try: 
+            return self._pkg_info 
+        except AttributeError: 
+            metadata = self.get_metadata(self.PKG_INFO) 
+            self._pkg_info = email.parser.Parser().parsestr(metadata) 
+            return self._pkg_info 
+ 
+    @property 
+    def _dep_map(self): 
+        try: 
+            return self.__dep_map 
+        except AttributeError: 
+            self.__dep_map = self._compute_dependencies() 
+            return self.__dep_map 
+ 
+    def _compute_dependencies(self): 
+        """Recompute this distribution's dependencies.""" 
+        dm = self.__dep_map = {None: []} 
+ 
+        reqs = [] 
+        # Including any condition expressions 
+        for req in self._parsed_pkg_info.get_all('Requires-Dist') or []: 
             reqs.extend(parse_requirements(req))
-
-        def reqs_for_extra(extra):
-            for req in reqs:
+ 
+        def reqs_for_extra(extra): 
+            for req in reqs: 
                 if not req.marker or req.marker.evaluate({'extra': extra}):
-                    yield req
-
-        common = frozenset(reqs_for_extra(None))
-        dm[None].extend(common)
-
-        for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
+                    yield req 
+ 
+        common = frozenset(reqs_for_extra(None)) 
+        dm[None].extend(common) 
+ 
+        for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []: 
             s_extra = safe_extra(extra.strip())
             dm[s_extra] = list(frozenset(reqs_for_extra(extra)) - common)
-
-        return dm
-
-
-_distributionImpl = {
-    '.egg': Distribution,
-    '.egg-info': EggInfoDistribution,
-    '.dist-info': DistInfoDistribution,
+ 
+        return dm 
+ 
+ 
+_distributionImpl = { 
+    '.egg': Distribution, 
+    '.egg-info': EggInfoDistribution, 
+    '.dist-info': DistInfoDistribution, 
 }
-
-
+ 
+ 
 def issue_warning(*args, **kw):
-    level = 1
-    g = globals()
-    try:
-        # find the first stack frame that is *not* code in
-        # the pkg_resources module, to use for the warning
-        while sys._getframe(level).f_globals is g:
-            level += 1
-    except ValueError:
-        pass
-    warnings.warn(stacklevel=level + 1, *args, **kw)
-
-
-class RequirementParseError(ValueError):
-    def __str__(self):
-        return ' '.join(self.args)
-
-
-def parse_requirements(strs):
-    """Yield ``Requirement`` objects for each specification in `strs`
-
-    `strs` must be a string, or a (possibly-nested) iterable thereof.
-    """
-    # create a steppable iterator, so we can handle \-continuations
-    lines = iter(yield_lines(strs))
-
-    for line in lines:
+    level = 1 
+    g = globals() 
+    try: 
+        # find the first stack frame that is *not* code in 
+        # the pkg_resources module, to use for the warning 
+        while sys._getframe(level).f_globals is g: 
+            level += 1 
+    except ValueError: 
+        pass 
+    warnings.warn(stacklevel=level + 1, *args, **kw) 
+ 
+ 
+class RequirementParseError(ValueError): 
+    def __str__(self): 
+        return ' '.join(self.args) 
+ 
+ 
+def parse_requirements(strs): 
+    """Yield ``Requirement`` objects for each specification in `strs` 
+ 
+    `strs` must be a string, or a (possibly-nested) iterable thereof. 
+    """ 
+    # create a steppable iterator, so we can handle \-continuations 
+    lines = iter(yield_lines(strs)) 
+ 
+    for line in lines: 
         # Drop comments -- a hash without a space may be in a URL.
         if ' #' in line:
             line = line[:line.find(' #')]
@@ -3092,63 +3092,63 @@ def parse_requirements(strs):
             except StopIteration:
                 return
         yield Requirement(line)
-
-
+ 
+ 
 class Requirement(packaging.requirements.Requirement):
     def __init__(self, requirement_string):
-        """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
+        """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!""" 
         try:
             super(Requirement, self).__init__(requirement_string)
         except packaging.requirements.InvalidRequirement as e:
             raise RequirementParseError(str(e))
         self.unsafe_name = self.name
         project_name = safe_name(self.name)
-        self.project_name, self.key = project_name, project_name.lower()
+        self.project_name, self.key = project_name, project_name.lower() 
         self.specs = [
             (spec.operator, spec.version) for spec in self.specifier]
         self.extras = tuple(map(safe_extra, self.extras))
-        self.hashCmp = (
-            self.key,
+        self.hashCmp = ( 
+            self.key, 
             self.url,
-            self.specifier,
-            frozenset(self.extras),
+            self.specifier, 
+            frozenset(self.extras), 
             str(self.marker) if self.marker else None,
-        )
-        self.__hash = hash(self.hashCmp)
-
-    def __eq__(self, other):
-        return (
-            isinstance(other, Requirement) and
-            self.hashCmp == other.hashCmp
-        )
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __contains__(self, item):
-        if isinstance(item, Distribution):
-            if item.key != self.key:
-                return False
-
-            item = item.version
-
-        # Allow prereleases always in order to match the previous behavior of
-        # this method. In the future this should be smarter and follow PEP 440
-        # more accurately.
-        return self.specifier.contains(item, prereleases=True)
-
-    def __hash__(self):
-        return self.__hash
-
+        ) 
+        self.__hash = hash(self.hashCmp) 
+ 
+    def __eq__(self, other): 
+        return ( 
+            isinstance(other, Requirement) and 
+            self.hashCmp == other.hashCmp 
+        ) 
+ 
+    def __ne__(self, other): 
+        return not self == other 
+ 
+    def __contains__(self, item): 
+        if isinstance(item, Distribution): 
+            if item.key != self.key: 
+                return False 
+ 
+            item = item.version 
+ 
+        # Allow prereleases always in order to match the previous behavior of 
+        # this method. In the future this should be smarter and follow PEP 440 
+        # more accurately. 
+        return self.specifier.contains(item, prereleases=True) 
+ 
+    def __hash__(self): 
+        return self.__hash 
+ 
     def __repr__(self):
         return "Requirement.parse(%r)" % str(self)
-
-    @staticmethod
-    def parse(s):
-        req, = parse_requirements(s)
-        return req
-
-
+ 
+    @staticmethod 
+    def parse(s): 
+        req, = parse_requirements(s) 
+        return req 
+ 
+ 
 def _always_object(classes):
     """
     Ensure object appears in the mro even
@@ -3159,70 +3159,70 @@ def _always_object(classes):
     return classes
 
 
-def _find_adapter(registry, ob):
-    """Return an adapter factory for `ob` from `registry`"""
+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:
-        if t in registry:
-            return registry[t]
-
-
-def ensure_directory(path):
-    """Ensure that the parent directory of `path` exists"""
-    dirname = os.path.dirname(path)
+        if t in registry: 
+            return registry[t] 
+ 
+ 
+def ensure_directory(path): 
+    """Ensure that the parent directory of `path` exists""" 
+    dirname = os.path.dirname(path) 
     py31compat.makedirs(dirname, exist_ok=True)
-
-
-def _bypass_ensure_directory(path):
-    """Sandbox-bypassing version of ensure_directory()"""
-    if not WRITE_SUPPORT:
-        raise IOError('"os.mkdir" not supported on this platform.')
-    dirname, filename = split(path)
-    if dirname and filename and not isdir(dirname):
-        _bypass_ensure_directory(dirname)
+ 
+ 
+def _bypass_ensure_directory(path): 
+    """Sandbox-bypassing version of ensure_directory()""" 
+    if not WRITE_SUPPORT: 
+        raise IOError('"os.mkdir" not supported on this platform.') 
+    dirname, filename = split(path) 
+    if dirname and filename and not isdir(dirname): 
+        _bypass_ensure_directory(dirname) 
         try:
             mkdir(dirname, 0o755)
         except FileExistsError:
             pass
-
-
-def split_sections(s):
-    """Split a string or iterable thereof into (section, content) pairs
-
-    Each ``section`` is a stripped version of the section header ("[section]")
-    and each ``content`` is a list of stripped lines excluding blank lines and
-    comment-only lines.  If there are any such lines before the first section
-    header, they're returned in a first ``section`` of ``None``.
-    """
-    section = None
-    content = []
-    for line in yield_lines(s):
-        if line.startswith("["):
-            if line.endswith("]"):
-                if section or content:
-                    yield section, content
-                section = line[1:-1].strip()
-                content = []
-            else:
-                raise ValueError("Invalid section heading", line)
-        else:
-            content.append(line)
-
-    # wrap up last segment
-    yield section, content
-
+ 
+ 
+def split_sections(s): 
+    """Split a string or iterable thereof into (section, content) pairs 
+ 
+    Each ``section`` is a stripped version of the section header ("[section]") 
+    and each ``content`` is a list of stripped lines excluding blank lines and 
+    comment-only lines.  If there are any such lines before the first section 
+    header, they're returned in a first ``section`` of ``None``. 
+    """ 
+    section = None 
+    content = [] 
+    for line in yield_lines(s): 
+        if line.startswith("["): 
+            if line.endswith("]"): 
+                if section or content: 
+                    yield section, content 
+                section = line[1:-1].strip() 
+                content = [] 
+            else: 
+                raise ValueError("Invalid section heading", line) 
+        else: 
+            content.append(line) 
+ 
+    # wrap up last segment 
+    yield section, content 
+ 
 
 def _mkstemp(*args, **kw):
-    old_open = os.open
-    try:
-        # temporarily bypass sandboxing
-        os.open = os_open
+    old_open = os.open 
+    try: 
+        # temporarily bypass sandboxing 
+        os.open = os_open 
         return tempfile.mkstemp(*args, **kw)
-    finally:
-        # and then put it back
-        os.open = old_open
-
-
+    finally: 
+        # and then put it back 
+        os.open = old_open 
+ 
+ 
 # Yandex resource support
 from __res import Y_PYTHON_SOURCE_ROOT, ResourceImporter, executable
 from library.python import resource
@@ -3311,53 +3311,53 @@ register_finder(ResourceImporter, find_in_res)
 register_loader_type(ResourceImporter, ResProvider.from_module)
 
 
-# Silence the PEP440Warning by default, so that end users don't get hit by it
-# randomly just because they use pkg_resources. We want to append the rule
-# because we want earlier uses of filterwarnings to take precedence over this
-# one.
-warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
-
-
-# from jaraco.functools 1.3
-def _call_aside(f, *args, **kwargs):
-    f(*args, **kwargs)
-    return f
-
-
-@_call_aside
-def _initialize(g=globals()):
-    "Set up global resource manager (deliberately not state-saved)"
-    manager = ResourceManager()
-    g['_manager'] = manager
+# Silence the PEP440Warning by default, so that end users don't get hit by it 
+# randomly just because they use pkg_resources. We want to append the rule 
+# because we want earlier uses of filterwarnings to take precedence over this 
+# one. 
+warnings.filterwarnings("ignore", category=PEP440Warning, append=True) 
+ 
+ 
+# from jaraco.functools 1.3 
+def _call_aside(f, *args, **kwargs): 
+    f(*args, **kwargs) 
+    return f 
+ 
+ 
+@_call_aside 
+def _initialize(g=globals()): 
+    "Set up global resource manager (deliberately not state-saved)" 
+    manager = ResourceManager() 
+    g['_manager'] = manager 
     g.update(
         (name, getattr(manager, name))
         for name in dir(manager)
         if not name.startswith('_')
     )
-
-
-@_call_aside
-def _initialize_master_working_set():
-    """
-    Prepare the master working set and make the ``require()``
-    API available.
-
-    This function has explicit effects on the global state
-    of pkg_resources. It is intended to be invoked once at
-    the initialization of this module.
-
-    Invocation by other packages is unsupported and done
-    at their own risk.
-    """
-    working_set = WorkingSet._build_master()
-    _declare_state('object', working_set=working_set)
-
-    require = working_set.require
-    iter_entry_points = working_set.iter_entry_points
-    add_activation_listener = working_set.subscribe
-    run_script = working_set.run_script
-    # backward compatibility
-    run_main = run_script
+ 
+ 
+@_call_aside 
+def _initialize_master_working_set(): 
+    """ 
+    Prepare the master working set and make the ``require()`` 
+    API available. 
+ 
+    This function has explicit effects on the global state 
+    of pkg_resources. It is intended to be invoked once at 
+    the initialization of this module. 
+ 
+    Invocation by other packages is unsupported and done 
+    at their own risk. 
+    """ 
+    working_set = WorkingSet._build_master() 
+    _declare_state('object', working_set=working_set) 
+ 
+    require = working_set.require 
+    iter_entry_points = working_set.iter_entry_points 
+    add_activation_listener = working_set.subscribe 
+    run_script = working_set.run_script 
+    # backward compatibility 
+    run_main = run_script 
     # Activate all distributions already on sys.path with replace=False and
     # ensure that all distributions added to the working set in the future
     # (e.g. by calling ``require()``) will get activated as well,
@@ -3371,9 +3371,9 @@ def _initialize_master_working_set():
         existing=False,
     )
     working_set.entries = []
-    # match order
-    list(map(working_set.add_entry, sys.path))
-    globals().update(locals())
+    # match order 
+    list(map(working_set.add_entry, sys.path)) 
+    globals().update(locals()) 
 
 class PkgResourcesDeprecationWarning(Warning):
     """
diff --git a/contrib/python/setuptools/py2/setuptools/__init__.py b/contrib/python/setuptools/py2/setuptools/__init__.py
index 9d8ae1ed5f..baa1ea0883 100644
--- a/contrib/python/setuptools/py2/setuptools/__init__.py
+++ b/contrib/python/setuptools/py2/setuptools/__init__.py
@@ -1,93 +1,93 @@
-"""Extensions to the 'distutils' for large or complex distributions"""
-
-import os
+"""Extensions to the 'distutils' for large or complex distributions""" 
+ 
+import os 
 import sys
-import functools
-import distutils.core
-import distutils.filelist
+import functools 
+import distutils.core 
+import distutils.filelist 
 import re
 from distutils.errors import DistutilsOptionError
-from distutils.util import convert_path
-from fnmatch import fnmatchcase
-
+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
 
-import setuptools.version
-from setuptools.extension import Extension
+import setuptools.version 
+from setuptools.extension import Extension 
 from setuptools.dist import Distribution, Feature
-from setuptools.depends import Require
+from setuptools.depends import Require 
 from . import monkey
-
+ 
 __metaclass__ = type
 
 
-__all__ = [
-    'setup', 'Distribution', 'Feature', 'Command', 'Extension', 'Require',
+__all__ = [ 
+    'setup', 'Distribution', 'Feature', 'Command', 'Extension', 'Require', 
     'SetuptoolsDeprecationWarning',
     'find_packages'
-]
-
+] 
+ 
 if PY3:
   __all__.append('find_namespace_packages')
 
-__version__ = setuptools.version.__version__
-
-bootstrap_install_from = None
-
-# If we run 2to3 on .py files, should we also convert docstrings?
-# Default: yes; assume that we can detect doctests reliably
-run_2to3_on_doctests = True
-# Standard package names for fixer packages
-lib2to3_fixer_packages = ['lib2to3.fixes']
-
-
+__version__ = setuptools.version.__version__ 
+ 
+bootstrap_install_from = None 
+ 
+# If we run 2to3 on .py files, should we also convert docstrings? 
+# Default: yes; assume that we can detect doctests reliably 
+run_2to3_on_doctests = True 
+# Standard package names for fixer packages 
+lib2to3_fixer_packages = ['lib2to3.fixes'] 
+ 
+ 
 class PackageFinder:
     """
     Generate a list of all Python packages found within a directory
     """
 
-    @classmethod
-    def find(cls, where='.', exclude=(), include=('*',)):
-        """Return a list all Python packages found within directory 'where'
-
+    @classmethod 
+    def find(cls, where='.', exclude=(), include=('*',)): 
+        """Return a list all Python packages found within directory 'where' 
+ 
         'where' is the root directory which will be searched for packages.  It
         should be supplied as a "cross-platform" (i.e. URL-style) path; it will
         be converted to the appropriate local path syntax.
 
-        'exclude' is a sequence of package names to exclude; '*' can be used
-        as a wildcard in the names, such that 'foo.*' will exclude all
-        subpackages of 'foo' (but not 'foo' itself).
-
-        'include' is a sequence of package names to include.  If it's
-        specified, only the named packages will be included.  If it's not
-        specified, all found packages will be included.  'include' can contain
-        shell style wildcard patterns just like 'exclude'.
-        """
-
+        'exclude' is a sequence of package names to exclude; '*' can be used 
+        as a wildcard in the names, such that 'foo.*' will exclude all 
+        subpackages of 'foo' (but not 'foo' itself). 
+ 
+        'include' is a sequence of package names to include.  If it's 
+        specified, only the named packages will be included.  If it's not 
+        specified, all found packages will be included.  'include' can contain 
+        shell style wildcard patterns just like 'exclude'. 
+        """ 
+ 
         return list(cls._find_packages_iter(
             convert_path(where),
             cls._build_filter('ez_setup', '*__pycache__', *exclude),
             cls._build_filter(*include)))
-
+ 
     @classmethod
     def _find_packages_iter(cls, where, exclude, include):
-        """
+        """ 
         All the packages found in 'where' that pass the 'include' filter, but
         not the 'exclude' filter.
-        """
+        """ 
         for root, dirs, files in os.walk(where, followlinks=True):
             # Copy dirs to iterate over it, then empty dirs.
             all_dirs = dirs[:]
             dirs[:] = []
-
+ 
             for dir in all_dirs:
                 full_path = os.path.join(root, dir)
                 rel_path = os.path.relpath(full_path, where)
                 package = rel_path.replace(os.path.sep, '.')
-
+ 
                 # Skip directory trees that are not valid packages
                 if ('.' in dir or not cls._looks_like_package(full_path)):
                     continue
@@ -100,31 +100,31 @@ class PackageFinder:
                 # down there, even if the parent was excluded.
                 dirs.append(dir)
 
-    @staticmethod
-    def _looks_like_package(path):
+    @staticmethod 
+    def _looks_like_package(path): 
         """Does a directory look like a package?"""
-        return os.path.isfile(os.path.join(path, '__init__.py'))
-
-    @staticmethod
-    def _build_filter(*patterns):
-        """
-        Given a list of patterns, return a callable that will be true only if
+        return os.path.isfile(os.path.join(path, '__init__.py')) 
+ 
+    @staticmethod 
+    def _build_filter(*patterns): 
+        """ 
+        Given a list of patterns, return a callable that will be true only if 
         the input matches at least one of the patterns.
-        """
-        return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns)
-
-
-class PEP420PackageFinder(PackageFinder):
-    @staticmethod
-    def _looks_like_package(path):
-        return True
-
-
-find_packages = PackageFinder.find
-
+        """ 
+        return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns) 
+ 
+
+class PEP420PackageFinder(PackageFinder): 
+    @staticmethod 
+    def _looks_like_package(path): 
+        return True 
+ 
+
+find_packages = PackageFinder.find 
+ 
 if PY3:
   find_namespace_packages = PEP420PackageFinder.find
-
+ 
 
 def _install_setup_requires(attrs):
     # Note: do not use `setuptools.Distribution` directly, as
@@ -165,21 +165,21 @@ setup.__doc__ = distutils.core.setup.__doc__
 
 
 _Command = monkey.get_unpatched(distutils.core.Command)
-
-
-class Command(_Command):
-    __doc__ = _Command.__doc__
-
-    command_consumes_arguments = False
-
-    def __init__(self, dist, **kw):
-        """
-        Construct the command for dist, updating
-        vars(self) with any keyword parameters.
-        """
-        _Command.__init__(self, dist)
-        vars(self).update(kw)
-
+ 
+
+class Command(_Command): 
+    __doc__ = _Command.__doc__ 
+ 
+    command_consumes_arguments = False 
+ 
+    def __init__(self, dist, **kw): 
+        """ 
+        Construct the command for dist, updating 
+        vars(self) with any keyword parameters. 
+        """ 
+        _Command.__init__(self, dist) 
+        vars(self).update(kw) 
+ 
     def _ensure_stringlike(self, option, what, default=None):
         val = getattr(self, option)
         if val is None:
@@ -211,35 +211,35 @@ class Command(_Command):
                       "'%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)
-        return cmd
-
-
-def _find_all_simple(path):
-    """
-    Find all files under 'path'
-    """
-    results = (
-        os.path.join(base, file)
-        for base, dirs, files in os.walk(path, followlinks=True)
-        for file in files
-    )
-    return filter(os.path.isfile, results)
-
-
-def findall(dir=os.curdir):
-    """
-    Find all files under 'dir' and return the list of full filenames.
-    Unless dir is '.', return full filenames with dir prepended.
-    """
-    files = _find_all_simple(dir)
-    if dir == os.curdir:
-        make_rel = functools.partial(os.path.relpath, start=dir)
-        files = map(make_rel, files)
-    return list(files)
-
-
+    def reinitialize_command(self, command, reinit_subcommands=0, **kw): 
+        cmd = _Command.reinitialize_command(self, command, reinit_subcommands) 
+        vars(cmd).update(kw) 
+        return cmd 
+ 
+ 
+def _find_all_simple(path): 
+    """ 
+    Find all files under 'path' 
+    """ 
+    results = ( 
+        os.path.join(base, file) 
+        for base, dirs, files in os.walk(path, followlinks=True) 
+        for file in files 
+    ) 
+    return filter(os.path.isfile, results) 
+ 
+ 
+def findall(dir=os.curdir): 
+    """ 
+    Find all files under 'dir' and return the list of full filenames. 
+    Unless dir is '.', return full filenames with dir prepended. 
+    """ 
+    files = _find_all_simple(dir) 
+    if dir == os.curdir: 
+        make_rel = functools.partial(os.path.relpath, start=dir) 
+        files = map(make_rel, files) 
+    return list(files) 
+ 
+ 
 # Apply monkey patches
 monkey.patch_all()
diff --git a/contrib/python/setuptools/py2/setuptools/archive_util.py b/contrib/python/setuptools/py2/setuptools/archive_util.py
index 81436044d9..82bb09a37b 100644
--- a/contrib/python/setuptools/py2/setuptools/archive_util.py
+++ b/contrib/python/setuptools/py2/setuptools/archive_util.py
@@ -1,13 +1,13 @@
-"""Utilities for extracting common archive formats"""
-
-import zipfile
-import tarfile
-import os
-import shutil
-import posixpath
-import contextlib
-from distutils.errors import DistutilsError
-
+"""Utilities for extracting common archive formats""" 
+ 
+import zipfile 
+import tarfile 
+import os 
+import shutil 
+import posixpath 
+import contextlib 
+from distutils.errors import DistutilsError 
+ 
 from pkg_resources import ensure_directory
 
 __all__ = [
@@ -16,158 +16,158 @@ __all__ = [
 ]
 
 
-class UnrecognizedFormat(DistutilsError):
-    """Couldn't recognize the archive type"""
-
+class UnrecognizedFormat(DistutilsError): 
+    """Couldn't recognize the archive type""" 
+ 
 
 def default_filter(src, dst):
-    """The default progress/filter callback; returns True for all files"""
-    return dst
-
-
-def unpack_archive(filename, extract_dir, progress_filter=default_filter,
-        drivers=None):
-    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
-
-    `progress_filter` is a function taking two arguments: a source path
-    internal to the archive ('/'-separated), and a filesystem path where it
-    will be extracted.  The callback must return the desired extract path
-    (which may be the same as the one passed in), or else ``None`` to skip
-    that file or directory.  The callback can thus be used to report on the
-    progress of the extraction, as well as to filter the items extracted or
-    alter their extraction paths.
-
-    `drivers`, if supplied, must be a non-empty sequence of functions with the
-    same signature as this function (minus the `drivers` argument), that raise
-    ``UnrecognizedFormat`` if they do not support extracting the designated
-    archive type.  The `drivers` are tried in sequence until one is found that
-    does not raise an error, or until all are exhausted (in which case
-    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of
-    drivers, the module's ``extraction_drivers`` constant will be used, which
-    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
-    order.
-    """
-    for driver in drivers or extraction_drivers:
-        try:
-            driver(filename, extract_dir, progress_filter)
-        except UnrecognizedFormat:
-            continue
-        else:
-            return
-    else:
-        raise UnrecognizedFormat(
-            "Not a recognized archive type: %s" % filename
-        )
-
-
-def unpack_directory(filename, extract_dir, progress_filter=default_filter):
-    """"Unpack" a directory, using the same interface as for archives
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a directory
-    """
-    if not os.path.isdir(filename):
-        raise UnrecognizedFormat("%s is not a directory" % filename)
-
-    paths = {
-        filename: ('', extract_dir),
-    }
-    for base, dirs, files in os.walk(filename):
-        src, dst = paths[base]
-        for d in dirs:
-            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
-        for f in files:
-            target = os.path.join(dst, f)
-            target = progress_filter(src + f, target)
-            if not target:
-                # skip non-files
-                continue
-            ensure_directory(target)
-            f = os.path.join(base, f)
-            shutil.copyfile(f, target)
-            shutil.copystat(f, target)
-
-
-def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack zip `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
-    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-
-    if not zipfile.is_zipfile(filename):
-        raise UnrecognizedFormat("%s is not a zip file" % (filename,))
-
+    """The default progress/filter callback; returns True for all files""" 
+    return dst 
+ 
+ 
+def unpack_archive(filename, extract_dir, progress_filter=default_filter, 
+        drivers=None): 
+    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat`` 
+ 
+    `progress_filter` is a function taking two arguments: a source path 
+    internal to the archive ('/'-separated), and a filesystem path where it 
+    will be extracted.  The callback must return the desired extract path 
+    (which may be the same as the one passed in), or else ``None`` to skip 
+    that file or directory.  The callback can thus be used to report on the 
+    progress of the extraction, as well as to filter the items extracted or 
+    alter their extraction paths. 
+ 
+    `drivers`, if supplied, must be a non-empty sequence of functions with the 
+    same signature as this function (minus the `drivers` argument), that raise 
+    ``UnrecognizedFormat`` if they do not support extracting the designated 
+    archive type.  The `drivers` are tried in sequence until one is found that 
+    does not raise an error, or until all are exhausted (in which case 
+    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of 
+    drivers, the module's ``extraction_drivers`` constant will be used, which 
+    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that 
+    order. 
+    """ 
+    for driver in drivers or extraction_drivers: 
+        try: 
+            driver(filename, extract_dir, progress_filter) 
+        except UnrecognizedFormat: 
+            continue 
+        else: 
+            return 
+    else: 
+        raise UnrecognizedFormat( 
+            "Not a recognized archive type: %s" % filename 
+        ) 
+ 
+ 
+def unpack_directory(filename, extract_dir, progress_filter=default_filter): 
+    """"Unpack" a directory, using the same interface as for archives 
+ 
+    Raises ``UnrecognizedFormat`` if `filename` is not a directory 
+    """ 
+    if not os.path.isdir(filename): 
+        raise UnrecognizedFormat("%s is not a directory" % filename) 
+ 
+    paths = { 
+        filename: ('', extract_dir), 
+    } 
+    for base, dirs, files in os.walk(filename): 
+        src, dst = paths[base] 
+        for d in dirs: 
+            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d) 
+        for f in files: 
+            target = os.path.join(dst, f) 
+            target = progress_filter(src + f, target) 
+            if not target: 
+                # skip non-files 
+                continue 
+            ensure_directory(target) 
+            f = os.path.join(base, f) 
+            shutil.copyfile(f, target) 
+            shutil.copystat(f, target) 
+ 
+ 
+def unpack_zipfile(filename, extract_dir, progress_filter=default_filter): 
+    """Unpack zip `filename` to `extract_dir` 
+ 
+    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined 
+    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation 
+    of the `progress_filter` argument. 
+    """ 
+ 
+    if not zipfile.is_zipfile(filename): 
+        raise UnrecognizedFormat("%s is not a zip file" % (filename,)) 
+ 
     with zipfile.ZipFile(filename) as z:
-        for info in z.infolist():
-            name = info.filename
-
-            # don't extract absolute paths or ones with .. in them
-            if name.startswith('/') or '..' in name.split('/'):
-                continue
-
-            target = os.path.join(extract_dir, *name.split('/'))
-            target = progress_filter(name, target)
-            if not target:
-                continue
-            if name.endswith('/'):
-                # directory
-                ensure_directory(target)
-            else:
-                # file
-                ensure_directory(target)
-                data = z.read(info.filename)
-                with open(target, 'wb') as f:
-                    f.write(data)
-            unix_attributes = info.external_attr >> 16
-            if unix_attributes:
-                os.chmod(target, unix_attributes)
-
-
-def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
-    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-    try:
-        tarobj = tarfile.open(filename)
-    except tarfile.TarError:
-        raise UnrecognizedFormat(
-            "%s is not a compressed or uncompressed tar file" % (filename,)
-        )
-    with contextlib.closing(tarobj):
-        # don't do any chowning!
-        tarobj.chown = lambda *args: None
-        for member in tarobj:
-            name = member.name
-            # don't extract absolute paths or ones with .. in them
-            if not name.startswith('/') and '..' not in name.split('/'):
-                prelim_dst = os.path.join(extract_dir, *name.split('/'))
-
-                # resolve any links and to extract the link targets as normal
-                # files
-                while member is not None and (member.islnk() or member.issym()):
-                    linkpath = member.linkname
-                    if member.issym():
-                        base = posixpath.dirname(member.name)
-                        linkpath = posixpath.join(base, linkpath)
-                        linkpath = posixpath.normpath(linkpath)
-                    member = tarobj._getmember(linkpath)
-
-                if member is not None and (member.isfile() or member.isdir()):
-                    final_dst = progress_filter(name, prelim_dst)
-                    if final_dst:
-                        if final_dst.endswith(os.sep):
-                            final_dst = final_dst[:-1]
-                        try:
-                            # XXX Ugh
-                            tarobj._extract_member(member, final_dst)
-                        except tarfile.ExtractError:
-                            # chown/chmod/mkfifo/mknode/makedev failed
-                            pass
-        return True
-
-
-extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile
+        for info in z.infolist(): 
+            name = info.filename 
+ 
+            # don't extract absolute paths or ones with .. in them 
+            if name.startswith('/') or '..' in name.split('/'): 
+                continue 
+ 
+            target = os.path.join(extract_dir, *name.split('/')) 
+            target = progress_filter(name, target) 
+            if not target: 
+                continue 
+            if name.endswith('/'): 
+                # directory 
+                ensure_directory(target) 
+            else: 
+                # file 
+                ensure_directory(target) 
+                data = z.read(info.filename) 
+                with open(target, 'wb') as f: 
+                    f.write(data) 
+            unix_attributes = info.external_attr >> 16 
+            if unix_attributes: 
+                os.chmod(target, unix_attributes) 
+ 
+ 
+def unpack_tarfile(filename, extract_dir, progress_filter=default_filter): 
+    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir` 
+ 
+    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined 
+    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation 
+    of the `progress_filter` argument. 
+    """ 
+    try: 
+        tarobj = tarfile.open(filename) 
+    except tarfile.TarError: 
+        raise UnrecognizedFormat( 
+            "%s is not a compressed or uncompressed tar file" % (filename,) 
+        ) 
+    with contextlib.closing(tarobj): 
+        # don't do any chowning! 
+        tarobj.chown = lambda *args: None 
+        for member in tarobj: 
+            name = member.name 
+            # don't extract absolute paths or ones with .. in them 
+            if not name.startswith('/') and '..' not in name.split('/'): 
+                prelim_dst = os.path.join(extract_dir, *name.split('/')) 
+ 
+                # resolve any links and to extract the link targets as normal 
+                # files 
+                while member is not None and (member.islnk() or member.issym()): 
+                    linkpath = member.linkname 
+                    if member.issym(): 
+                        base = posixpath.dirname(member.name) 
+                        linkpath = posixpath.join(base, linkpath) 
+                        linkpath = posixpath.normpath(linkpath) 
+                    member = tarobj._getmember(linkpath) 
+ 
+                if member is not None and (member.isfile() or member.isdir()): 
+                    final_dst = progress_filter(name, prelim_dst) 
+                    if final_dst: 
+                        if final_dst.endswith(os.sep): 
+                            final_dst = final_dst[:-1] 
+                        try: 
+                            # XXX Ugh 
+                            tarobj._extract_member(member, final_dst) 
+                        except tarfile.ExtractError: 
+                            # chown/chmod/mkfifo/mknode/makedev failed 
+                            pass 
+        return True 
+ 
+
+extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile 
diff --git a/contrib/python/setuptools/py2/setuptools/command/__init__.py b/contrib/python/setuptools/py2/setuptools/command/__init__.py
index 743f5588fa..f335601c84 100644
--- a/contrib/python/setuptools/py2/setuptools/command/__init__.py
+++ b/contrib/python/setuptools/py2/setuptools/command/__init__.py
@@ -1,17 +1,17 @@
-__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',
+__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',
-]
-
-from distutils.command.bdist import bdist
-import sys
-
-from setuptools.command import install_scripts
-
-if 'egg' not in bdist.format_commands:
-    bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
-    bdist.format_commands.append('egg')
-
-del bdist, sys
+] 
+ 
+from distutils.command.bdist import bdist 
+import sys 
+ 
+from setuptools.command import install_scripts 
+ 
+if 'egg' not in bdist.format_commands: 
+    bdist.format_command['egg'] = ('bdist_egg', "Python .egg file") 
+    bdist.format_commands.append('egg') 
+ 
+del bdist, sys 
diff --git a/contrib/python/setuptools/py2/setuptools/command/alias.py b/contrib/python/setuptools/py2/setuptools/command/alias.py
index 4532b1cc0d..c057825904 100644
--- a/contrib/python/setuptools/py2/setuptools/command/alias.py
+++ b/contrib/python/setuptools/py2/setuptools/command/alias.py
@@ -1,80 +1,80 @@
-from distutils.errors import DistutilsOptionError
-
+from distutils.errors import DistutilsOptionError 
+ 
 from setuptools.extern.six.moves import map
-
-from setuptools.command.setopt import edit_config, option_base, config_file
-
-
-def shquote(arg):
-    """Quote an argument for later parsing by shlex.split()"""
-    for c in '"', "'", "\\", "#":
-        if c in arg:
-            return repr(arg)
-    if arg.split() != [arg]:
-        return repr(arg)
-    return arg
-
-
-class alias(option_base):
-    """Define a shortcut that invokes one or more commands"""
-
-    description = "define a shortcut to invoke one or more commands"
-    command_consumes_arguments = True
-
-    user_options = [
-        ('remove', 'r', 'remove (unset) the alias'),
-    ] + option_base.user_options
-
-    boolean_options = option_base.boolean_options + ['remove']
-
-    def initialize_options(self):
-        option_base.initialize_options(self)
-        self.args = None
-        self.remove = None
-
-    def finalize_options(self):
-        option_base.finalize_options(self)
-        if self.remove and len(self.args) != 1:
-            raise DistutilsOptionError(
-                "Must specify exactly one argument (the alias name) when "
-                "using --remove"
-            )
-
-    def run(self):
-        aliases = self.distribution.get_option_dict('aliases')
-
-        if not self.args:
-            print("Command Aliases")
-            print("---------------")
-            for alias in aliases:
-                print("setup.py alias", format_alias(alias, aliases))
-            return
-
-        elif len(self.args) == 1:
-            alias, = self.args
-            if self.remove:
-                command = None
-            elif alias in aliases:
-                print("setup.py alias", format_alias(alias, aliases))
-                return
-            else:
-                print("No alias definition found for %r" % alias)
-                return
-        else:
-            alias = self.args[0]
-            command = ' '.join(map(shquote, self.args[1:]))
-
-        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)
-
-
-def format_alias(name, aliases):
-    source, command = aliases[name]
-    if source == config_file('global'):
-        source = '--global-config '
-    elif source == config_file('user'):
-        source = '--user-config '
-    elif source == config_file('local'):
-        source = ''
-    else:
-        source = '--filename=%r' % source
-    return source + name + ' ' + command
+ 
+from setuptools.command.setopt import edit_config, option_base, config_file 
+ 
+ 
+def shquote(arg): 
+    """Quote an argument for later parsing by shlex.split()""" 
+    for c in '"', "'", "\\", "#": 
+        if c in arg: 
+            return repr(arg) 
+    if arg.split() != [arg]: 
+        return repr(arg) 
+    return arg 
+ 
+ 
+class alias(option_base): 
+    """Define a shortcut that invokes one or more commands""" 
+ 
+    description = "define a shortcut to invoke one or more commands" 
+    command_consumes_arguments = True 
+ 
+    user_options = [ 
+        ('remove', 'r', 'remove (unset) the alias'), 
+    ] + option_base.user_options 
+ 
+    boolean_options = option_base.boolean_options + ['remove'] 
+ 
+    def initialize_options(self): 
+        option_base.initialize_options(self) 
+        self.args = None 
+        self.remove = None 
+ 
+    def finalize_options(self): 
+        option_base.finalize_options(self) 
+        if self.remove and len(self.args) != 1: 
+            raise DistutilsOptionError( 
+                "Must specify exactly one argument (the alias name) when " 
+                "using --remove" 
+            ) 
+ 
+    def run(self): 
+        aliases = self.distribution.get_option_dict('aliases') 
+ 
+        if not self.args: 
+            print("Command Aliases") 
+            print("---------------") 
+            for alias in aliases: 
+                print("setup.py alias", format_alias(alias, aliases)) 
+            return 
+ 
+        elif len(self.args) == 1: 
+            alias, = self.args 
+            if self.remove: 
+                command = None 
+            elif alias in aliases: 
+                print("setup.py alias", format_alias(alias, aliases)) 
+                return 
+            else: 
+                print("No alias definition found for %r" % alias) 
+                return 
+        else: 
+            alias = self.args[0] 
+            command = ' '.join(map(shquote, self.args[1:])) 
+ 
+        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run) 
+ 
+ 
+def format_alias(name, aliases): 
+    source, command = aliases[name] 
+    if source == config_file('global'): 
+        source = '--global-config ' 
+    elif source == config_file('user'): 
+        source = '--user-config ' 
+    elif source == config_file('local'): 
+        source = '' 
+    else: 
+        source = '--filename=%r' % source 
+    return source + name + ' ' + command 
diff --git a/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py b/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py
index 98470f1715..798c044589 100644
--- a/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py
+++ b/contrib/python/setuptools/py2/setuptools/command/bdist_egg.py
@@ -1,45 +1,45 @@
-"""setuptools.command.bdist_egg
-
-Build .egg distributions"""
-
-from distutils.errors import DistutilsSetupError
-from distutils.dir_util import remove_tree, mkpath
-from distutils import log
-from types import CodeType
-import sys
-import os
+"""setuptools.command.bdist_egg 
+ 
+Build .egg distributions""" 
+ 
+from distutils.errors import DistutilsSetupError 
+from distutils.dir_util import remove_tree, mkpath 
+from distutils import log 
+from types import CodeType 
+import sys 
+import os 
 import re
 import textwrap
-import marshal
-
+import marshal 
+ 
 from setuptools.extern import six
-
-from pkg_resources import get_build_platform, Distribution, ensure_directory
-from pkg_resources import EntryPoint
-from setuptools.extension import Library
-from setuptools import Command
-
-try:
-    # Python 2.7 or >=3.2
-    from sysconfig import get_path, get_python_version
-
-    def _get_purelib():
-        return get_path("purelib")
-except ImportError:
-    from distutils.sysconfig import get_python_lib, get_python_version
-
-    def _get_purelib():
-        return get_python_lib(False)
-
-
-def strip_module(filename):
-    if '.' in filename:
-        filename = os.path.splitext(filename)[0]
-    if filename.endswith('module'):
-        filename = filename[:-6]
-    return filename
-
-
+ 
+from pkg_resources import get_build_platform, Distribution, ensure_directory 
+from pkg_resources import EntryPoint 
+from setuptools.extension import Library 
+from setuptools import Command 
+ 
+try: 
+    # Python 2.7 or >=3.2 
+    from sysconfig import get_path, get_python_version 
+ 
+    def _get_purelib(): 
+        return get_path("purelib") 
+except ImportError: 
+    from distutils.sysconfig import get_python_lib, get_python_version 
+ 
+    def _get_purelib(): 
+        return get_python_lib(False) 
+ 
+ 
+def strip_module(filename): 
+    if '.' in filename: 
+        filename = os.path.splitext(filename)[0] 
+    if filename.endswith('module'): 
+        filename = filename[:-6] 
+    return filename 
+ 
+ 
 def sorted_walk(dir):
     """Do os.walk in a reproducible way,
     independent of indeterministic filesystem readdir order
@@ -50,205 +50,205 @@ def sorted_walk(dir):
         yield base, dirs, files
 
 
-def write_stub(resource, pyfile):
-    _stub_template = textwrap.dedent("""
-        def __bootstrap__():
-            global __bootstrap__, __loader__, __file__
-            import sys, pkg_resources, imp
-            __file__ = pkg_resources.resource_filename(__name__, %r)
-            __loader__ = None; del __bootstrap__, __loader__
-            imp.load_dynamic(__name__,__file__)
-        __bootstrap__()
-        """).lstrip()
-    with open(pyfile, 'w') as f:
-        f.write(_stub_template % resource)
-
-
-class bdist_egg(Command):
-    description = "create an \"egg\" distribution"
-
-    user_options = [
-        ('bdist-dir=', 'b',
-         "temporary directory for creating the distribution"),
-        ('plat-name=', 'p', "platform name to embed in generated filenames "
-                            "(default: %s)" % get_build_platform()),
-        ('exclude-source-files', None,
-         "remove all .py files from the generated egg"),
-        ('keep-temp', 'k',
-         "keep the pseudo-installation tree around after " +
-         "creating the distribution archive"),
-        ('dist-dir=', 'd',
-         "directory to put final built distributions in"),
-        ('skip-build', None,
-         "skip rebuilding everything (for testing/debugging)"),
-    ]
-
-    boolean_options = [
-        'keep-temp', 'skip-build', 'exclude-source-files'
-    ]
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.keep_temp = 0
-        self.dist_dir = None
-        self.skip_build = 0
-        self.egg_output = None
-        self.exclude_source_files = None
-
-    def finalize_options(self):
-        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
-        self.egg_info = ei_cmd.egg_info
-
-        if self.bdist_dir is None:
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'egg')
-
-        if self.plat_name is None:
-            self.plat_name = get_build_platform()
-
-        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
-
-        if self.egg_output is None:
-
-            # Compute filename of the output egg
-            basename = Distribution(
-                None, None, ei_cmd.egg_name, ei_cmd.egg_version,
-                get_python_version(),
-                self.distribution.has_ext_modules() and self.plat_name
-            ).egg_name()
-
-            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
-
-    def do_install_data(self):
-        # Hack for packages that install data to install's --install-lib
-        self.get_finalized_command('install').install_lib = self.bdist_dir
-
-        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
-        old, self.distribution.data_files = self.distribution.data_files, []
-
-        for item in old:
-            if isinstance(item, tuple) and len(item) == 2:
-                if os.path.isabs(item[0]):
-                    realpath = os.path.realpath(item[0])
-                    normalized = os.path.normcase(realpath)
-                    if normalized == site_packages or normalized.startswith(
-                        site_packages + os.sep
-                    ):
-                        item = realpath[len(site_packages) + 1:], item[1]
-                        # XXX else: raise ???
-            self.distribution.data_files.append(item)
-
-        try:
+def write_stub(resource, pyfile): 
+    _stub_template = textwrap.dedent(""" 
+        def __bootstrap__(): 
+            global __bootstrap__, __loader__, __file__ 
+            import sys, pkg_resources, imp 
+            __file__ = pkg_resources.resource_filename(__name__, %r) 
+            __loader__ = None; del __bootstrap__, __loader__ 
+            imp.load_dynamic(__name__,__file__) 
+        __bootstrap__() 
+        """).lstrip() 
+    with open(pyfile, 'w') as f: 
+        f.write(_stub_template % resource) 
+ 
+ 
+class bdist_egg(Command): 
+    description = "create an \"egg\" distribution" 
+ 
+    user_options = [ 
+        ('bdist-dir=', 'b', 
+         "temporary directory for creating the distribution"), 
+        ('plat-name=', 'p', "platform name to embed in generated filenames " 
+                            "(default: %s)" % get_build_platform()), 
+        ('exclude-source-files', None, 
+         "remove all .py files from the generated egg"), 
+        ('keep-temp', 'k', 
+         "keep the pseudo-installation tree around after " + 
+         "creating the distribution archive"), 
+        ('dist-dir=', 'd', 
+         "directory to put final built distributions in"), 
+        ('skip-build', None, 
+         "skip rebuilding everything (for testing/debugging)"), 
+    ] 
+ 
+    boolean_options = [ 
+        'keep-temp', 'skip-build', 'exclude-source-files' 
+    ] 
+ 
+    def initialize_options(self): 
+        self.bdist_dir = None 
+        self.plat_name = None 
+        self.keep_temp = 0 
+        self.dist_dir = None 
+        self.skip_build = 0 
+        self.egg_output = None 
+        self.exclude_source_files = None 
+ 
+    def finalize_options(self): 
+        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info") 
+        self.egg_info = ei_cmd.egg_info 
+ 
+        if self.bdist_dir is None: 
+            bdist_base = self.get_finalized_command('bdist').bdist_base 
+            self.bdist_dir = os.path.join(bdist_base, 'egg') 
+ 
+        if self.plat_name is None: 
+            self.plat_name = get_build_platform() 
+ 
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir')) 
+ 
+        if self.egg_output is None: 
+ 
+            # Compute filename of the output egg 
+            basename = Distribution( 
+                None, None, ei_cmd.egg_name, ei_cmd.egg_version, 
+                get_python_version(), 
+                self.distribution.has_ext_modules() and self.plat_name 
+            ).egg_name() 
+ 
+            self.egg_output = os.path.join(self.dist_dir, basename + '.egg') 
+ 
+    def do_install_data(self): 
+        # Hack for packages that install data to install's --install-lib 
+        self.get_finalized_command('install').install_lib = self.bdist_dir 
+ 
+        site_packages = os.path.normcase(os.path.realpath(_get_purelib())) 
+        old, self.distribution.data_files = self.distribution.data_files, [] 
+ 
+        for item in old: 
+            if isinstance(item, tuple) and len(item) == 2: 
+                if os.path.isabs(item[0]): 
+                    realpath = os.path.realpath(item[0]) 
+                    normalized = os.path.normcase(realpath) 
+                    if normalized == site_packages or normalized.startswith( 
+                        site_packages + os.sep 
+                    ): 
+                        item = realpath[len(site_packages) + 1:], item[1] 
+                        # XXX else: raise ??? 
+            self.distribution.data_files.append(item) 
+ 
+        try: 
             log.info("installing package data to %s", self.bdist_dir)
-            self.call_command('install_data', force=0, root=None)
-        finally:
-            self.distribution.data_files = old
-
-    def get_outputs(self):
-        return [self.egg_output]
-
-    def call_command(self, cmdname, **kw):
-        """Invoke reinitialized command `cmdname` with keyword args"""
-        for dirname in INSTALL_DIRECTORY_ATTRS:
-            kw.setdefault(dirname, self.bdist_dir)
-        kw.setdefault('skip_build', self.skip_build)
-        kw.setdefault('dry_run', self.dry_run)
-        cmd = self.reinitialize_command(cmdname, **kw)
-        self.run_command(cmdname)
-        return cmd
-
-    def run(self):
-        # Generate metadata first
-        self.run_command("egg_info")
-        # We run install_lib before install_data, because some data hacks
-        # pull their data path from the install_lib command.
+            self.call_command('install_data', force=0, root=None) 
+        finally: 
+            self.distribution.data_files = old 
+ 
+    def get_outputs(self): 
+        return [self.egg_output] 
+ 
+    def call_command(self, cmdname, **kw): 
+        """Invoke reinitialized command `cmdname` with keyword args""" 
+        for dirname in INSTALL_DIRECTORY_ATTRS: 
+            kw.setdefault(dirname, self.bdist_dir) 
+        kw.setdefault('skip_build', self.skip_build) 
+        kw.setdefault('dry_run', self.dry_run) 
+        cmd = self.reinitialize_command(cmdname, **kw) 
+        self.run_command(cmdname) 
+        return cmd 
+ 
+    def run(self): 
+        # Generate metadata first 
+        self.run_command("egg_info") 
+        # We run install_lib before install_data, because some data hacks 
+        # pull their data path from the install_lib command. 
         log.info("installing library code to %s", self.bdist_dir)
-        instcmd = self.get_finalized_command('install')
-        old_root = instcmd.root
-        instcmd.root = None
-        if self.distribution.has_c_libraries() and not self.skip_build:
-            self.run_command('build_clib')
-        cmd = self.call_command('install_lib', warn_dir=0)
-        instcmd.root = old_root
-
-        all_outputs, ext_outputs = self.get_ext_outputs()
-        self.stubs = []
-        to_compile = []
-        for (p, ext_name) in enumerate(ext_outputs):
-            filename, ext = os.path.splitext(ext_name)
-            pyfile = os.path.join(self.bdist_dir, strip_module(filename) +
-                                  '.py')
-            self.stubs.append(pyfile)
+        instcmd = self.get_finalized_command('install') 
+        old_root = instcmd.root 
+        instcmd.root = None 
+        if self.distribution.has_c_libraries() and not self.skip_build: 
+            self.run_command('build_clib') 
+        cmd = self.call_command('install_lib', warn_dir=0) 
+        instcmd.root = old_root 
+ 
+        all_outputs, ext_outputs = self.get_ext_outputs() 
+        self.stubs = [] 
+        to_compile = [] 
+        for (p, ext_name) in enumerate(ext_outputs): 
+            filename, ext = os.path.splitext(ext_name) 
+            pyfile = os.path.join(self.bdist_dir, strip_module(filename) + 
+                                  '.py') 
+            self.stubs.append(pyfile) 
             log.info("creating stub loader for %s", ext_name)
-            if not self.dry_run:
-                write_stub(os.path.basename(ext_name), pyfile)
-            to_compile.append(pyfile)
-            ext_outputs[p] = ext_name.replace(os.sep, '/')
-
-        if to_compile:
-            cmd.byte_compile(to_compile)
-        if self.distribution.data_files:
-            self.do_install_data()
-
-        # Make the EGG-INFO directory
-        archive_root = self.bdist_dir
-        egg_info = os.path.join(archive_root, 'EGG-INFO')
-        self.mkpath(egg_info)
-        if self.distribution.scripts:
-            script_dir = os.path.join(egg_info, 'scripts')
+            if not self.dry_run: 
+                write_stub(os.path.basename(ext_name), pyfile) 
+            to_compile.append(pyfile) 
+            ext_outputs[p] = ext_name.replace(os.sep, '/') 
+ 
+        if to_compile: 
+            cmd.byte_compile(to_compile) 
+        if self.distribution.data_files: 
+            self.do_install_data() 
+ 
+        # Make the EGG-INFO directory 
+        archive_root = self.bdist_dir 
+        egg_info = os.path.join(archive_root, 'EGG-INFO') 
+        self.mkpath(egg_info) 
+        if self.distribution.scripts: 
+            script_dir = os.path.join(egg_info, 'scripts') 
             log.info("installing scripts to %s", script_dir)
-            self.call_command('install_scripts', install_dir=script_dir,
-                              no_ep=1)
-
-        self.copy_metadata_to(egg_info)
-        native_libs = os.path.join(egg_info, "native_libs.txt")
-        if all_outputs:
+            self.call_command('install_scripts', install_dir=script_dir, 
+                              no_ep=1) 
+ 
+        self.copy_metadata_to(egg_info) 
+        native_libs = os.path.join(egg_info, "native_libs.txt") 
+        if all_outputs: 
             log.info("writing %s", native_libs)
-            if not self.dry_run:
-                ensure_directory(native_libs)
-                libs_file = open(native_libs, 'wt')
-                libs_file.write('\n'.join(all_outputs))
-                libs_file.write('\n')
-                libs_file.close()
-        elif os.path.isfile(native_libs):
+            if not self.dry_run: 
+                ensure_directory(native_libs) 
+                libs_file = open(native_libs, 'wt') 
+                libs_file.write('\n'.join(all_outputs)) 
+                libs_file.write('\n') 
+                libs_file.close() 
+        elif os.path.isfile(native_libs): 
             log.info("removing %s", native_libs)
-            if not self.dry_run:
-                os.unlink(native_libs)
-
-        write_safety_flag(
-            os.path.join(archive_root, 'EGG-INFO'), self.zip_safe()
-        )
-
-        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
-            log.warn(
-                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
-                "Use the install_requires/extras_require setup() args instead."
-            )
-
-        if self.exclude_source_files:
-            self.zap_pyfiles()
-
-        # Make the archive
-        make_zipfile(self.egg_output, archive_root, verbose=self.verbose,
-                     dry_run=self.dry_run, mode=self.gen_header())
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
-
-        # Add to 'Distribution.dist_files' so that the "upload" command works
-        getattr(self.distribution, 'dist_files', []).append(
-            ('bdist_egg', get_python_version(), self.egg_output))
-
-    def zap_pyfiles(self):
-        log.info("Removing .py files from temporary directory")
-        for base, dirs, files in walk_egg(self.bdist_dir):
-            for name in files:
+            if not self.dry_run: 
+                os.unlink(native_libs) 
+ 
+        write_safety_flag( 
+            os.path.join(archive_root, 'EGG-INFO'), self.zip_safe() 
+        ) 
+ 
+        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')): 
+            log.warn( 
+                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n" 
+                "Use the install_requires/extras_require setup() args instead." 
+            ) 
+ 
+        if self.exclude_source_files: 
+            self.zap_pyfiles() 
+ 
+        # Make the archive 
+        make_zipfile(self.egg_output, archive_root, verbose=self.verbose, 
+                     dry_run=self.dry_run, mode=self.gen_header()) 
+        if not self.keep_temp: 
+            remove_tree(self.bdist_dir, dry_run=self.dry_run) 
+ 
+        # Add to 'Distribution.dist_files' so that the "upload" command works 
+        getattr(self.distribution, 'dist_files', []).append( 
+            ('bdist_egg', get_python_version(), self.egg_output)) 
+ 
+    def zap_pyfiles(self): 
+        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)
 
-                if name.endswith('.py'):
-                    log.debug("Deleting %s", path)
-                    os.unlink(path)
-
+                if name.endswith('.py'): 
+                    log.debug("Deleting %s", path) 
+                    os.unlink(path) 
+ 
                 if base.endswith('__pycache__'):
                     path_old = path
 
@@ -265,238 +265,238 @@ class bdist_egg(Command):
                         pass
                     os.rename(path_old, path_new)
 
-    def zip_safe(self):
-        safe = getattr(self.distribution, 'zip_safe', None)
-        if safe is not None:
-            return safe
-        log.warn("zip_safe flag not set; analyzing archive contents...")
-        return analyze_egg(self.bdist_dir, self.stubs)
-
-    def gen_header(self):
-        epm = EntryPoint.parse_map(self.distribution.entry_points or '')
-        ep = epm.get('setuptools.installation', {}).get('eggsecutable')
-        if ep is None:
-            return 'w'  # not an eggsecutable, do it the usual way.
-
-        if not ep.attrs or ep.extras:
-            raise DistutilsSetupError(
-                "eggsecutable entry point (%r) cannot have 'extras' "
-                "or refer to a module" % (ep,)
-            )
-
+    def zip_safe(self): 
+        safe = getattr(self.distribution, 'zip_safe', None) 
+        if safe is not None: 
+            return safe 
+        log.warn("zip_safe flag not set; analyzing archive contents...") 
+        return analyze_egg(self.bdist_dir, self.stubs) 
+ 
+    def gen_header(self): 
+        epm = EntryPoint.parse_map(self.distribution.entry_points or '') 
+        ep = epm.get('setuptools.installation', {}).get('eggsecutable') 
+        if ep is None: 
+            return 'w'  # not an eggsecutable, do it the usual way. 
+ 
+        if not ep.attrs or ep.extras: 
+            raise DistutilsSetupError( 
+                "eggsecutable entry point (%r) cannot have 'extras' " 
+                "or refer to a module" % (ep,) 
+            ) 
+ 
         pyver = '{}.{}'.format(*sys.version_info)
-        pkg = ep.module_name
-        full = '.'.join(ep.attrs)
-        base = ep.attrs[0]
-        basename = os.path.basename(self.egg_output)
-
-        header = (
-            "#!/bin/sh\n"
-            'if [ `basename $0` = "%(basename)s" ]\n'
-            'then exec python%(pyver)s -c "'
-            "import sys, os; sys.path.insert(0, os.path.abspath('$0')); "
-            "from %(pkg)s import %(base)s; sys.exit(%(full)s())"
-            '" "$@"\n'
-            'else\n'
-            '  echo $0 is not the correct name for this egg file.\n'
-            '  echo Please rename it back to %(basename)s and try again.\n'
-            '  exec false\n'
-            'fi\n'
-        ) % locals()
-
-        if not self.dry_run:
-            mkpath(os.path.dirname(self.egg_output), dry_run=self.dry_run)
-            f = open(self.egg_output, 'w')
-            f.write(header)
-            f.close()
-        return 'a'
-
-    def copy_metadata_to(self, target_dir):
-        "Copy metadata (egg info) to the target_dir"
-        # normalize the path (so that a forward-slash in egg_info will
-        # match using startswith below)
-        norm_egg_info = os.path.normpath(self.egg_info)
-        prefix = os.path.join(norm_egg_info, '')
-        for path in self.ei_cmd.filelist.files:
-            if path.startswith(prefix):
-                target = os.path.join(target_dir, path[len(prefix):])
-                ensure_directory(target)
-                self.copy_file(path, target)
-
-    def get_ext_outputs(self):
-        """Get a list of relative paths to C extensions in the output distro"""
-
-        all_outputs = []
-        ext_outputs = []
-
-        paths = {self.bdist_dir: ''}
+        pkg = ep.module_name 
+        full = '.'.join(ep.attrs) 
+        base = ep.attrs[0] 
+        basename = os.path.basename(self.egg_output) 
+ 
+        header = ( 
+            "#!/bin/sh\n" 
+            'if [ `basename $0` = "%(basename)s" ]\n' 
+            'then exec python%(pyver)s -c "' 
+            "import sys, os; sys.path.insert(0, os.path.abspath('$0')); " 
+            "from %(pkg)s import %(base)s; sys.exit(%(full)s())" 
+            '" "$@"\n' 
+            'else\n' 
+            '  echo $0 is not the correct name for this egg file.\n' 
+            '  echo Please rename it back to %(basename)s and try again.\n' 
+            '  exec false\n' 
+            'fi\n' 
+        ) % locals() 
+ 
+        if not self.dry_run: 
+            mkpath(os.path.dirname(self.egg_output), dry_run=self.dry_run) 
+            f = open(self.egg_output, 'w') 
+            f.write(header) 
+            f.close() 
+        return 'a' 
+ 
+    def copy_metadata_to(self, target_dir): 
+        "Copy metadata (egg info) to the target_dir" 
+        # normalize the path (so that a forward-slash in egg_info will 
+        # match using startswith below) 
+        norm_egg_info = os.path.normpath(self.egg_info) 
+        prefix = os.path.join(norm_egg_info, '') 
+        for path in self.ei_cmd.filelist.files: 
+            if path.startswith(prefix): 
+                target = os.path.join(target_dir, path[len(prefix):]) 
+                ensure_directory(target) 
+                self.copy_file(path, target) 
+ 
+    def get_ext_outputs(self): 
+        """Get a list of relative paths to C extensions in the output distro""" 
+ 
+        all_outputs = [] 
+        ext_outputs = [] 
+ 
+        paths = {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)
-            for filename in dirs:
-                paths[os.path.join(base, filename)] = (paths[base] +
-                                                       filename + '/')
-
-        if self.distribution.has_ext_modules():
-            build_cmd = self.get_finalized_command('build_ext')
-            for ext in build_cmd.extensions:
-                if isinstance(ext, Library):
-                    continue
-                fullname = build_cmd.get_ext_fullname(ext.name)
-                filename = build_cmd.get_ext_filename(fullname)
-                if not os.path.basename(filename).startswith('dl-'):
-                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
-                        ext_outputs.append(filename)
-
-        return all_outputs, ext_outputs
-
-
-NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())
-
-
-def walk_egg(egg_dir):
-    """Walk an unpacked egg's contents, skipping the metadata directory"""
+            for filename in files: 
+                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS: 
+                    all_outputs.append(paths[base] + filename) 
+            for filename in dirs: 
+                paths[os.path.join(base, filename)] = (paths[base] + 
+                                                       filename + '/') 
+ 
+        if self.distribution.has_ext_modules(): 
+            build_cmd = self.get_finalized_command('build_ext') 
+            for ext in build_cmd.extensions: 
+                if isinstance(ext, Library): 
+                    continue 
+                fullname = build_cmd.get_ext_fullname(ext.name) 
+                filename = build_cmd.get_ext_filename(fullname) 
+                if not os.path.basename(filename).startswith('dl-'): 
+                    if os.path.exists(os.path.join(self.bdist_dir, filename)): 
+                        ext_outputs.append(filename) 
+ 
+        return all_outputs, ext_outputs 
+ 
+ 
+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)
-    base, dirs, files = next(walker)
-    if 'EGG-INFO' in dirs:
-        dirs.remove('EGG-INFO')
-    yield base, dirs, files
-    for bdf in walker:
-        yield bdf
-
-
-def analyze_egg(egg_dir, stubs):
-    # check for existing flag in EGG-INFO
-    for flag, fn in safety_flags.items():
-        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
-            return flag
-    if not can_scan():
-        return False
-    safe = True
-    for base, dirs, files in walk_egg(egg_dir):
-        for name in files:
-            if name.endswith('.py') or name.endswith('.pyw'):
-                continue
-            elif name.endswith('.pyc') or name.endswith('.pyo'):
-                # always scan, even if we already know we're not safe
-                safe = scan_module(egg_dir, base, name, stubs) and safe
-    return safe
-
-
-def write_safety_flag(egg_dir, safe):
-    # Write or remove zip safety flag file(s)
-    for flag, fn in safety_flags.items():
-        fn = os.path.join(egg_dir, fn)
-        if os.path.exists(fn):
-            if safe is None or bool(safe) != flag:
-                os.unlink(fn)
-        elif safe is not None and bool(safe) == flag:
-            f = open(fn, 'wt')
-            f.write('\n')
-            f.close()
-
-
-safety_flags = {
-    True: 'zip-safe',
-    False: 'not-zip-safe',
-}
-
-
-def scan_module(egg_dir, base, name, stubs):
-    """Check whether module possibly uses unsafe-for-zipfile stuff"""
-
-    filename = os.path.join(base, name)
-    if filename[:-1] in stubs:
-        return True  # Extension module
-    pkg = base[len(egg_dir) + 1:].replace(os.sep, '.')
-    module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
+    base, dirs, files = next(walker) 
+    if 'EGG-INFO' in dirs: 
+        dirs.remove('EGG-INFO') 
+    yield base, dirs, files 
+    for bdf in walker: 
+        yield bdf 
+ 
+ 
+def analyze_egg(egg_dir, stubs): 
+    # check for existing flag in EGG-INFO 
+    for flag, fn in safety_flags.items(): 
+        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)): 
+            return flag 
+    if not can_scan(): 
+        return False 
+    safe = True 
+    for base, dirs, files in walk_egg(egg_dir): 
+        for name in files: 
+            if name.endswith('.py') or name.endswith('.pyw'): 
+                continue 
+            elif name.endswith('.pyc') or name.endswith('.pyo'): 
+                # always scan, even if we already know we're not safe 
+                safe = scan_module(egg_dir, base, name, stubs) and safe 
+    return safe 
+ 
+ 
+def write_safety_flag(egg_dir, safe): 
+    # Write or remove zip safety flag file(s) 
+    for flag, fn in safety_flags.items(): 
+        fn = os.path.join(egg_dir, fn) 
+        if os.path.exists(fn): 
+            if safe is None or bool(safe) != flag: 
+                os.unlink(fn) 
+        elif safe is not None and bool(safe) == flag: 
+            f = open(fn, 'wt') 
+            f.write('\n') 
+            f.close() 
+ 
+ 
+safety_flags = { 
+    True: 'zip-safe', 
+    False: 'not-zip-safe', 
+} 
+ 
+ 
+def scan_module(egg_dir, base, name, stubs): 
+    """Check whether module possibly uses unsafe-for-zipfile stuff""" 
+ 
+    filename = os.path.join(base, name) 
+    if filename[:-1] in 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:
-        skip = 8  # skip magic & date
+        skip = 8  # skip magic & date 
     elif sys.version_info < (3, 7):
         skip = 12  # skip magic & date & file size
-    else:
+    else: 
         skip = 16  # skip magic & reserved? & date & file size
-    f = open(filename, 'rb')
-    f.read(skip)
-    code = marshal.load(f)
-    f.close()
-    safe = True
-    symbols = dict.fromkeys(iter_symbols(code))
-    for bad in ['__file__', '__path__']:
-        if bad in symbols:
-            log.warn("%s: module references %s", module, bad)
-            safe = False
-    if 'inspect' in symbols:
-        for bad in [
-            'getsource', 'getabsfile', 'getsourcefile', 'getfile'
-            'getsourcelines', 'findsource', 'getcomments', 'getframeinfo',
-            'getinnerframes', 'getouterframes', 'stack', 'trace'
-        ]:
-            if bad in symbols:
-                log.warn("%s: module MAY be using inspect.%s", module, bad)
-                safe = False
-    return safe
-
-
-def iter_symbols(code):
-    """Yield names and strings used by `code` and its nested code objects"""
-    for name in code.co_names:
-        yield name
-    for const in code.co_consts:
-        if isinstance(const, six.string_types):
-            yield const
-        elif isinstance(const, CodeType):
-            for name in iter_symbols(const):
-                yield name
-
-
-def can_scan():
-    if not sys.platform.startswith('java') and sys.platform != 'cli':
-        # CPython, PyPy, etc.
-        return True
-    log.warn("Unable to analyze compiled code on this platform.")
-    log.warn("Please ask the author to include a 'zip_safe'"
-             " setting (either True or False) in the package's setup.py")
-
-
-# Attribute names of options for commands that might need to be convinced to
-# install to the egg build directory
-
-INSTALL_DIRECTORY_ATTRS = [
-    'install_lib', 'install_dir', 'install_data', 'install_base'
-]
-
-
-def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
-                 mode='w'):
-    """Create a zip file from all the files under 'base_dir'.  The output
-    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
-    Python module (if available) or the InfoZIP "zip" utility (if installed
-    and found on the default search path).  If neither tool is available,
-    raises DistutilsExecError.  Returns the name of the output zip file.
-    """
-    import zipfile
-
-    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
-    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
-
-    def visit(z, dirname, names):
-        for name in names:
-            path = os.path.normpath(os.path.join(dirname, name))
-            if os.path.isfile(path):
-                p = path[len(base_dir) + 1:]
-                if not dry_run:
-                    z.write(path, p)
+    f = open(filename, 'rb') 
+    f.read(skip) 
+    code = marshal.load(f) 
+    f.close() 
+    safe = True 
+    symbols = dict.fromkeys(iter_symbols(code)) 
+    for bad in ['__file__', '__path__']: 
+        if bad in symbols: 
+            log.warn("%s: module references %s", module, bad) 
+            safe = False 
+    if 'inspect' in symbols: 
+        for bad in [ 
+            'getsource', 'getabsfile', 'getsourcefile', 'getfile' 
+            'getsourcelines', 'findsource', 'getcomments', 'getframeinfo', 
+            'getinnerframes', 'getouterframes', 'stack', 'trace' 
+        ]: 
+            if bad in symbols: 
+                log.warn("%s: module MAY be using inspect.%s", module, bad) 
+                safe = False 
+    return safe 
+ 
+ 
+def iter_symbols(code): 
+    """Yield names and strings used by `code` and its nested code objects""" 
+    for name in code.co_names: 
+        yield name 
+    for const in code.co_consts: 
+        if isinstance(const, six.string_types): 
+            yield const 
+        elif isinstance(const, CodeType): 
+            for name in iter_symbols(const): 
+                yield name 
+ 
+ 
+def can_scan(): 
+    if not sys.platform.startswith('java') and sys.platform != 'cli': 
+        # CPython, PyPy, etc. 
+        return True 
+    log.warn("Unable to analyze compiled code on this platform.") 
+    log.warn("Please ask the author to include a 'zip_safe'" 
+             " setting (either True or False) in the package's setup.py") 
+ 
+
+# Attribute names of options for commands that might need to be convinced to 
+# install to the egg build directory 
+ 
+INSTALL_DIRECTORY_ATTRS = [ 
+    'install_lib', 'install_dir', 'install_data', 'install_base' 
+] 
+ 
+ 
+def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True, 
+                 mode='w'): 
+    """Create a zip file from all the files under 'base_dir'.  The output 
+    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile" 
+    Python module (if available) or the InfoZIP "zip" utility (if installed 
+    and found on the default search path).  If neither tool is available, 
+    raises DistutilsExecError.  Returns the name of the output zip file. 
+    """ 
+    import zipfile 
+ 
+    mkpath(os.path.dirname(zip_filename), dry_run=dry_run) 
+    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir) 
+ 
+    def visit(z, dirname, names): 
+        for name in names: 
+            path = os.path.normpath(os.path.join(dirname, name)) 
+            if os.path.isfile(path): 
+                p = path[len(base_dir) + 1:] 
+                if not dry_run: 
+                    z.write(path, p) 
                 log.debug("adding '%s'", p)
-
-    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
-    if not dry_run:
-        z = zipfile.ZipFile(zip_filename, mode, compression=compression)
+ 
+    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):
-            visit(z, dirname, files)
-        z.close()
-    else:
+            visit(z, dirname, files) 
+        z.close() 
+    else: 
         for dirname, dirs, files in sorted_walk(base_dir):
-            visit(None, dirname, files)
-    return zip_filename
+            visit(None, dirname, files) 
+    return zip_filename 
diff --git a/contrib/python/setuptools/py2/setuptools/command/bdist_rpm.py b/contrib/python/setuptools/py2/setuptools/command/bdist_rpm.py
index 70730927ec..5f1a15e2d9 100644
--- a/contrib/python/setuptools/py2/setuptools/command/bdist_rpm.py
+++ b/contrib/python/setuptools/py2/setuptools/command/bdist_rpm.py
@@ -1,43 +1,43 @@
-import distutils.command.bdist_rpm as orig
-
-
-class bdist_rpm(orig.bdist_rpm):
-    """
-    Override the default bdist_rpm behavior to do the following:
-
-    1. Run egg_info to ensure the name and version are properly calculated.
-    2. Always run 'install' using --single-version-externally-managed to
-       disable eggs in RPM distributions.
-    3. Replace dash with underscore in the version numbers for better RPM
-       compatibility.
-    """
-
-    def run(self):
-        # ensure distro name is up-to-date
-        self.run_command('egg_info')
-
-        orig.bdist_rpm.run(self)
-
-    def _make_spec_file(self):
-        version = self.distribution.get_version()
-        rpmversion = version.replace('-', '_')
-        spec = orig.bdist_rpm._make_spec_file(self)
-        line23 = '%define version ' + version
-        line24 = '%define version ' + rpmversion
-        spec = [
-            line.replace(
-                "Source0: %{name}-%{version}.tar",
-                "Source0: %{name}-%{unmangled_version}.tar"
-            ).replace(
-                "setup.py install ",
-                "setup.py install --single-version-externally-managed "
-            ).replace(
-                "%setup",
-                "%setup -n %{name}-%{unmangled_version}"
-            ).replace(line23, line24)
-            for line in spec
-        ]
-        insert_loc = spec.index(line24) + 1
-        unmangled_version = "%define unmangled_version " + version
-        spec.insert(insert_loc, unmangled_version)
-        return spec
+import distutils.command.bdist_rpm as orig 
+ 
+ 
+class bdist_rpm(orig.bdist_rpm): 
+    """ 
+    Override the default bdist_rpm behavior to do the following: 
+ 
+    1. Run egg_info to ensure the name and version are properly calculated. 
+    2. Always run 'install' using --single-version-externally-managed to 
+       disable eggs in RPM distributions. 
+    3. Replace dash with underscore in the version numbers for better RPM 
+       compatibility. 
+    """ 
+ 
+    def run(self): 
+        # ensure distro name is up-to-date 
+        self.run_command('egg_info') 
+ 
+        orig.bdist_rpm.run(self) 
+ 
+    def _make_spec_file(self): 
+        version = self.distribution.get_version() 
+        rpmversion = version.replace('-', '_') 
+        spec = orig.bdist_rpm._make_spec_file(self) 
+        line23 = '%define version ' + version 
+        line24 = '%define version ' + rpmversion 
+        spec = [ 
+            line.replace( 
+                "Source0: %{name}-%{version}.tar", 
+                "Source0: %{name}-%{unmangled_version}.tar" 
+            ).replace( 
+                "setup.py install ", 
+                "setup.py install --single-version-externally-managed " 
+            ).replace( 
+                "%setup", 
+                "%setup -n %{name}-%{unmangled_version}" 
+            ).replace(line23, line24) 
+            for line in spec 
+        ] 
+        insert_loc = spec.index(line24) + 1 
+        unmangled_version = "%define unmangled_version " + version 
+        spec.insert(insert_loc, unmangled_version) 
+        return spec 
diff --git a/contrib/python/setuptools/py2/setuptools/command/bdist_wininst.py b/contrib/python/setuptools/py2/setuptools/command/bdist_wininst.py
index 073de97b46..9ca62d60c3 100644
--- a/contrib/python/setuptools/py2/setuptools/command/bdist_wininst.py
+++ b/contrib/python/setuptools/py2/setuptools/command/bdist_wininst.py
@@ -1,21 +1,21 @@
-import distutils.command.bdist_wininst as orig
-
-
-class bdist_wininst(orig.bdist_wininst):
-    def reinitialize_command(self, command, reinit_subcommands=0):
-        """
-        Supplement reinitialize_command to work around
-        http://bugs.python.org/issue20819
-        """
-        cmd = self.distribution.reinitialize_command(
-            command, reinit_subcommands)
-        if command in ('install', 'install_lib'):
-            cmd.install_lib = None
-        return cmd
-
-    def run(self):
-        self._is_running = True
-        try:
-            orig.bdist_wininst.run(self)
-        finally:
-            self._is_running = False
+import distutils.command.bdist_wininst as orig 
+ 
+ 
+class bdist_wininst(orig.bdist_wininst): 
+    def reinitialize_command(self, command, reinit_subcommands=0): 
+        """ 
+        Supplement reinitialize_command to work around 
+        http://bugs.python.org/issue20819 
+        """ 
+        cmd = self.distribution.reinitialize_command( 
+            command, reinit_subcommands) 
+        if command in ('install', 'install_lib'): 
+            cmd.install_lib = None 
+        return cmd 
+ 
+    def run(self): 
+        self._is_running = True 
+        try: 
+            orig.bdist_wininst.run(self) 
+        finally: 
+            self._is_running = False 
diff --git a/contrib/python/setuptools/py2/setuptools/command/build_ext.py b/contrib/python/setuptools/py2/setuptools/command/build_ext.py
index 1b51e040b4..235ad9d305 100644
--- a/contrib/python/setuptools/py2/setuptools/command/build_ext.py
+++ b/contrib/python/setuptools/py2/setuptools/command/build_ext.py
@@ -1,16 +1,16 @@
 import os
 import sys
 import itertools
-from distutils.command.build_ext import build_ext as _du_build_ext
-from distutils.file_util import copy_file
-from distutils.ccompiler import new_compiler
+from distutils.command.build_ext import build_ext as _du_build_ext 
+from distutils.file_util import copy_file 
+from distutils.ccompiler import new_compiler 
 from distutils.sysconfig import customize_compiler, get_config_var
-from distutils.errors import DistutilsError
-from distutils import log
-
-from setuptools.extension import Library
+from distutils.errors import DistutilsError 
+from distutils import log 
+ 
+from setuptools.extension import Library 
 from setuptools.extern import six
-
+ 
 if six.PY2:
     import imp
 
@@ -18,20 +18,20 @@ if six.PY2:
 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
+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')
-except ImportError:
-    _build_ext = _du_build_ext
-
+except ImportError: 
+    _build_ext = _du_build_ext 
+ 
 # make sure _config_vars is initialized
 get_config_var("LDSHARED")
 from distutils.sysconfig import _config_vars as _CONFIG_VARS
-
-
+ 
+ 
 def _customize_compiler_for_shlib(compiler):
     if sys.platform == "darwin":
         # building .dylib requires additional compiler flags on OSX; here we
@@ -52,21 +52,21 @@ def _customize_compiler_for_shlib(compiler):
         customize_compiler(compiler)
 
 
-have_rtld = False
-use_stubs = False
-libtype = 'shared'
-
-if sys.platform == "darwin":
-    use_stubs = True
-elif os.name != 'nt':
-    try:
-        import dl
-        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
-    except ImportError:
-        pass
-
-if_dl = lambda s: s if have_rtld else ''
-
+have_rtld = False 
+use_stubs = False 
+libtype = 'shared' 
+ 
+if sys.platform == "darwin": 
+    use_stubs = True 
+elif os.name != 'nt': 
+    try: 
+        import dl 
+        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW') 
+    except ImportError: 
+        pass 
+ 
+if_dl = lambda s: s if have_rtld else '' 
+ 
 
 def get_abi3_suffix():
     """Return the file extension for an abi3-compliant Extension()"""
@@ -77,41 +77,41 @@ def get_abi3_suffix():
             return suffix
 
 
-class build_ext(_build_ext):
-    def run(self):
-        """Build extensions in build directory, then copy if --inplace"""
-        old_inplace, self.inplace = self.inplace, 0
-        _build_ext.run(self)
-        self.inplace = old_inplace
-        if old_inplace:
-            self.copy_extensions_to_source()
-
-    def copy_extensions_to_source(self):
-        build_py = self.get_finalized_command('build_py')
-        for ext in self.extensions:
-            fullname = self.get_ext_fullname(ext.name)
-            filename = self.get_ext_filename(fullname)
-            modpath = fullname.split('.')
-            package = '.'.join(modpath[:-1])
-            package_dir = build_py.get_package_dir(package)
-            dest_filename = os.path.join(package_dir,
-                                         os.path.basename(filename))
-            src_filename = os.path.join(self.build_lib, filename)
-
-            # Always copy, even if source is older than destination, to ensure
-            # that the right extensions for the current Python/platform are
-            # used.
-            copy_file(
-                src_filename, dest_filename, verbose=self.verbose,
-                dry_run=self.dry_run
-            )
-            if ext._needs_stub:
-                self.write_stub(package_dir or os.curdir, ext, True)
-
-    def get_ext_filename(self, fullname):
-        filename = _build_ext.get_ext_filename(self, fullname)
-        if fullname in self.ext_map:
-            ext = self.ext_map[fullname]
+class build_ext(_build_ext): 
+    def run(self): 
+        """Build extensions in build directory, then copy if --inplace""" 
+        old_inplace, self.inplace = self.inplace, 0 
+        _build_ext.run(self) 
+        self.inplace = old_inplace 
+        if old_inplace: 
+            self.copy_extensions_to_source() 
+ 
+    def copy_extensions_to_source(self): 
+        build_py = self.get_finalized_command('build_py') 
+        for ext in self.extensions: 
+            fullname = self.get_ext_fullname(ext.name) 
+            filename = self.get_ext_filename(fullname) 
+            modpath = fullname.split('.') 
+            package = '.'.join(modpath[:-1]) 
+            package_dir = build_py.get_package_dir(package) 
+            dest_filename = os.path.join(package_dir, 
+                                         os.path.basename(filename)) 
+            src_filename = os.path.join(self.build_lib, filename) 
+ 
+            # Always copy, even if source is older than destination, to ensure 
+            # that the right extensions for the current Python/platform are 
+            # used. 
+            copy_file( 
+                src_filename, dest_filename, verbose=self.verbose, 
+                dry_run=self.dry_run 
+            ) 
+            if ext._needs_stub: 
+                self.write_stub(package_dir or os.curdir, ext, True) 
+ 
+    def get_ext_filename(self, fullname): 
+        filename = _build_ext.get_ext_filename(self, fullname) 
+        if fullname in self.ext_map: 
+            ext = self.ext_map[fullname] 
             use_abi3 = (
                 not six.PY2
                 and getattr(ext, 'py_limited_api')
@@ -121,207 +121,207 @@ class build_ext(_build_ext):
                 so_ext = get_config_var('EXT_SUFFIX')
                 filename = filename[:-len(so_ext)]
                 filename = filename + get_abi3_suffix()
-            if isinstance(ext, Library):
-                fn, ext = os.path.splitext(filename)
-                return self.shlib_compiler.library_filename(fn, libtype)
-            elif use_stubs and ext._links_to_dynamic:
-                d, fn = os.path.split(filename)
-                return os.path.join(d, 'dl-' + fn)
-        return filename
-
-    def initialize_options(self):
-        _build_ext.initialize_options(self)
-        self.shlib_compiler = None
-        self.shlibs = []
-        self.ext_map = {}
-
-    def finalize_options(self):
-        _build_ext.finalize_options(self)
-        self.extensions = self.extensions or []
-        self.check_extensions_list(self.extensions)
-        self.shlibs = [ext for ext in self.extensions
-                       if isinstance(ext, Library)]
-        if self.shlibs:
-            self.setup_shlib_compiler()
-        for ext in self.extensions:
-            ext._full_name = self.get_ext_fullname(ext.name)
-        for ext in self.extensions:
-            fullname = ext._full_name
-            self.ext_map[fullname] = ext
-
-            # distutils 3.1 will also ask for module names
-            # XXX what to do with conflicts?
-            self.ext_map[fullname.split('.')[-1]] = ext
-
-            ltd = self.shlibs and self.links_to_dynamic(ext) or False
-            ns = ltd and use_stubs and not isinstance(ext, Library)
-            ext._links_to_dynamic = ltd
-            ext._needs_stub = ns
-            filename = ext._file_name = self.get_ext_filename(fullname)
-            libdir = os.path.dirname(os.path.join(self.build_lib, filename))
-            if ltd and libdir not in ext.library_dirs:
-                ext.library_dirs.append(libdir)
-            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
-                ext.runtime_library_dirs.append(os.curdir)
-
-    def setup_shlib_compiler(self):
-        compiler = self.shlib_compiler = new_compiler(
-            compiler=self.compiler, dry_run=self.dry_run, force=self.force
-        )
+            if isinstance(ext, Library): 
+                fn, ext = os.path.splitext(filename) 
+                return self.shlib_compiler.library_filename(fn, libtype) 
+            elif use_stubs and ext._links_to_dynamic: 
+                d, fn = os.path.split(filename) 
+                return os.path.join(d, 'dl-' + fn) 
+        return filename 
+ 
+    def initialize_options(self): 
+        _build_ext.initialize_options(self) 
+        self.shlib_compiler = None 
+        self.shlibs = [] 
+        self.ext_map = {} 
+ 
+    def finalize_options(self): 
+        _build_ext.finalize_options(self) 
+        self.extensions = self.extensions or [] 
+        self.check_extensions_list(self.extensions) 
+        self.shlibs = [ext for ext in self.extensions 
+                       if isinstance(ext, Library)] 
+        if self.shlibs: 
+            self.setup_shlib_compiler() 
+        for ext in self.extensions: 
+            ext._full_name = self.get_ext_fullname(ext.name) 
+        for ext in self.extensions: 
+            fullname = ext._full_name 
+            self.ext_map[fullname] = ext 
+ 
+            # distutils 3.1 will also ask for module names 
+            # XXX what to do with conflicts? 
+            self.ext_map[fullname.split('.')[-1]] = ext 
+ 
+            ltd = self.shlibs and self.links_to_dynamic(ext) or False 
+            ns = ltd and use_stubs and not isinstance(ext, Library) 
+            ext._links_to_dynamic = ltd 
+            ext._needs_stub = ns 
+            filename = ext._file_name = self.get_ext_filename(fullname) 
+            libdir = os.path.dirname(os.path.join(self.build_lib, filename)) 
+            if ltd and libdir not in ext.library_dirs: 
+                ext.library_dirs.append(libdir) 
+            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs: 
+                ext.runtime_library_dirs.append(os.curdir) 
+ 
+    def setup_shlib_compiler(self): 
+        compiler = self.shlib_compiler = new_compiler( 
+            compiler=self.compiler, dry_run=self.dry_run, force=self.force 
+        ) 
         _customize_compiler_for_shlib(compiler)
-
-        if self.include_dirs is not None:
-            compiler.set_include_dirs(self.include_dirs)
-        if self.define is not None:
-            # 'define' option is a list of (name,value) tuples
-            for (name, value) in self.define:
-                compiler.define_macro(name, value)
-        if self.undef is not None:
-            for macro in self.undef:
-                compiler.undefine_macro(macro)
-        if self.libraries is not None:
-            compiler.set_libraries(self.libraries)
-        if self.library_dirs is not None:
-            compiler.set_library_dirs(self.library_dirs)
-        if self.rpath is not None:
-            compiler.set_runtime_library_dirs(self.rpath)
-        if self.link_objects is not None:
-            compiler.set_link_objects(self.link_objects)
-
-        # hack so distutils' build_extension() builds a library instead
-        compiler.link_shared_object = link_shared_object.__get__(compiler)
-
-    def get_export_symbols(self, ext):
-        if isinstance(ext, Library):
-            return ext.export_symbols
-        return _build_ext.get_export_symbols(self, ext)
-
-    def build_extension(self, ext):
-        ext._convert_pyx_sources_to_lang()
-        _compiler = self.compiler
-        try:
-            if isinstance(ext, Library):
-                self.compiler = self.shlib_compiler
-            _build_ext.build_extension(self, ext)
-            if ext._needs_stub:
-                cmd = self.get_finalized_command('build_py').build_lib
-                self.write_stub(cmd, ext)
-        finally:
-            self.compiler = _compiler
-
-    def links_to_dynamic(self, ext):
-        """Return true if 'ext' links to a dynamic lib in the same package"""
-        # XXX this should check to ensure the lib is actually being built
-        # XXX as dynamic, and not just using a locally-found version or a
-        # XXX static-compiled version
-        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
-        pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
-        return any(pkg + libname in libnames for libname in ext.libraries)
-
-    def get_outputs(self):
-        return _build_ext.get_outputs(self) + self.__get_stubs_outputs()
-
-    def __get_stubs_outputs(self):
-        # assemble the base name for each extension that needs a stub
-        ns_ext_bases = (
-            os.path.join(self.build_lib, *ext._full_name.split('.'))
-            for ext in self.extensions
-            if ext._needs_stub
-        )
-        # pair each base with the extension
-        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
-        return list(base + fnext for base, fnext in pairs)
-
-    def __get_output_extensions(self):
-        yield '.py'
-        yield '.pyc'
-        if self.get_finalized_command('build_py').optimize:
-            yield '.pyo'
-
-    def write_stub(self, output_dir, ext, compile=False):
-        log.info("writing stub loader for %s to %s", ext._full_name,
-                 output_dir)
-        stub_file = (os.path.join(output_dir, *ext._full_name.split('.')) +
-                     '.py')
-        if compile and os.path.exists(stub_file):
-            raise DistutilsError(stub_file + " already exists! Please delete.")
-        if not self.dry_run:
-            f = open(stub_file, 'w')
-            f.write(
-                '\n'.join([
-                    "def __bootstrap__():",
-                    "   global __bootstrap__, __file__, __loader__",
-                    "   import sys, os, pkg_resources, imp" + if_dl(", dl"),
-                    "   __file__ = pkg_resources.resource_filename"
-                    "(__name__,%r)"
-                    % os.path.basename(ext._file_name),
-                    "   del __bootstrap__",
-                    "   if '__loader__' in globals():",
-                    "       del __loader__",
-                    if_dl("   old_flags = sys.getdlopenflags()"),
-                    "   old_dir = os.getcwd()",
-                    "   try:",
-                    "     os.chdir(os.path.dirname(__file__))",
-                    if_dl("     sys.setdlopenflags(dl.RTLD_NOW)"),
-                    "     imp.load_dynamic(__name__,__file__)",
-                    "   finally:",
-                    if_dl("     sys.setdlopenflags(old_flags)"),
-                    "     os.chdir(old_dir)",
-                    "__bootstrap__()",
-                    ""  # terminal \n
-                ])
-            )
-            f.close()
-        if compile:
-            from distutils.util import byte_compile
-
-            byte_compile([stub_file], optimize=0,
-                         force=True, dry_run=self.dry_run)
-            optimize = self.get_finalized_command('install_lib').optimize
-            if optimize > 0:
-                byte_compile([stub_file], optimize=optimize,
-                             force=True, dry_run=self.dry_run)
-            if os.path.exists(stub_file) and not self.dry_run:
-                os.unlink(stub_file)
-
-
-if use_stubs or os.name == 'nt':
-    # Build shared libraries
-    #
-    def link_shared_object(
-            self, objects, output_libname, output_dir=None, libraries=None,
-            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
-            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
-            target_lang=None):
-        self.link(
-            self.SHARED_LIBRARY, objects, output_libname,
-            output_dir, libraries, library_dirs, runtime_library_dirs,
-            export_symbols, debug, extra_preargs, extra_postargs,
-            build_temp, target_lang
-        )
-else:
-    # Build static libraries everywhere else
-    libtype = 'static'
-
-    def link_shared_object(
-            self, objects, output_libname, output_dir=None, libraries=None,
-            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
-            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
-            target_lang=None):
-        # XXX we need to either disallow these attrs on Library instances,
-        # or warn/abort here if set, or something...
-        # libraries=None, library_dirs=None, runtime_library_dirs=None,
-        # export_symbols=None, extra_preargs=None, extra_postargs=None,
-        # build_temp=None
-
-        assert output_dir is None  # distutils build_ext doesn't pass this
-        output_dir, filename = os.path.split(output_libname)
-        basename, ext = os.path.splitext(filename)
-        if self.library_filename("x").startswith('lib'):
-            # strip 'lib' prefix; this is kludgy if some platform uses
-            # a different prefix
-            basename = basename[3:]
-
-        self.create_static_lib(
-            objects, basename, output_dir, debug, target_lang
-        )
+ 
+        if self.include_dirs is not None: 
+            compiler.set_include_dirs(self.include_dirs) 
+        if self.define is not None: 
+            # 'define' option is a list of (name,value) tuples 
+            for (name, value) in self.define: 
+                compiler.define_macro(name, value) 
+        if self.undef is not None: 
+            for macro in self.undef: 
+                compiler.undefine_macro(macro) 
+        if self.libraries is not None: 
+            compiler.set_libraries(self.libraries) 
+        if self.library_dirs is not None: 
+            compiler.set_library_dirs(self.library_dirs) 
+        if self.rpath is not None: 
+            compiler.set_runtime_library_dirs(self.rpath) 
+        if self.link_objects is not None: 
+            compiler.set_link_objects(self.link_objects) 
+ 
+        # hack so distutils' build_extension() builds a library instead 
+        compiler.link_shared_object = link_shared_object.__get__(compiler) 
+ 
+    def get_export_symbols(self, ext): 
+        if isinstance(ext, Library): 
+            return ext.export_symbols 
+        return _build_ext.get_export_symbols(self, ext) 
+ 
+    def build_extension(self, ext): 
+        ext._convert_pyx_sources_to_lang() 
+        _compiler = self.compiler 
+        try: 
+            if isinstance(ext, Library): 
+                self.compiler = self.shlib_compiler 
+            _build_ext.build_extension(self, ext) 
+            if ext._needs_stub: 
+                cmd = self.get_finalized_command('build_py').build_lib 
+                self.write_stub(cmd, ext) 
+        finally: 
+            self.compiler = _compiler 
+ 
+    def links_to_dynamic(self, ext): 
+        """Return true if 'ext' links to a dynamic lib in the same package""" 
+        # XXX this should check to ensure the lib is actually being built 
+        # XXX as dynamic, and not just using a locally-found version or a 
+        # XXX static-compiled version 
+        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs]) 
+        pkg = '.'.join(ext._full_name.split('.')[:-1] + ['']) 
+        return any(pkg + libname in libnames for libname in ext.libraries) 
+ 
+    def get_outputs(self): 
+        return _build_ext.get_outputs(self) + self.__get_stubs_outputs() 
+ 
+    def __get_stubs_outputs(self): 
+        # assemble the base name for each extension that needs a stub 
+        ns_ext_bases = ( 
+            os.path.join(self.build_lib, *ext._full_name.split('.')) 
+            for ext in self.extensions 
+            if ext._needs_stub 
+        ) 
+        # pair each base with the extension 
+        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions()) 
+        return list(base + fnext for base, fnext in pairs) 
+ 
+    def __get_output_extensions(self): 
+        yield '.py' 
+        yield '.pyc' 
+        if self.get_finalized_command('build_py').optimize: 
+            yield '.pyo' 
+ 
+    def write_stub(self, output_dir, ext, compile=False): 
+        log.info("writing stub loader for %s to %s", ext._full_name, 
+                 output_dir) 
+        stub_file = (os.path.join(output_dir, *ext._full_name.split('.')) + 
+                     '.py') 
+        if compile and os.path.exists(stub_file): 
+            raise DistutilsError(stub_file + " already exists! Please delete.") 
+        if not self.dry_run: 
+            f = open(stub_file, 'w') 
+            f.write( 
+                '\n'.join([ 
+                    "def __bootstrap__():", 
+                    "   global __bootstrap__, __file__, __loader__", 
+                    "   import sys, os, pkg_resources, imp" + if_dl(", dl"), 
+                    "   __file__ = pkg_resources.resource_filename" 
+                    "(__name__,%r)" 
+                    % os.path.basename(ext._file_name), 
+                    "   del __bootstrap__", 
+                    "   if '__loader__' in globals():", 
+                    "       del __loader__", 
+                    if_dl("   old_flags = sys.getdlopenflags()"), 
+                    "   old_dir = os.getcwd()", 
+                    "   try:", 
+                    "     os.chdir(os.path.dirname(__file__))", 
+                    if_dl("     sys.setdlopenflags(dl.RTLD_NOW)"), 
+                    "     imp.load_dynamic(__name__,__file__)", 
+                    "   finally:", 
+                    if_dl("     sys.setdlopenflags(old_flags)"), 
+                    "     os.chdir(old_dir)", 
+                    "__bootstrap__()", 
+                    ""  # terminal \n 
+                ]) 
+            ) 
+            f.close() 
+        if compile: 
+            from distutils.util import byte_compile 
+ 
+            byte_compile([stub_file], optimize=0, 
+                         force=True, dry_run=self.dry_run) 
+            optimize = self.get_finalized_command('install_lib').optimize 
+            if optimize > 0: 
+                byte_compile([stub_file], optimize=optimize, 
+                             force=True, dry_run=self.dry_run) 
+            if os.path.exists(stub_file) and not self.dry_run: 
+                os.unlink(stub_file) 
+ 
+ 
+if use_stubs or os.name == 'nt': 
+    # Build shared libraries 
+    # 
+    def link_shared_object( 
+            self, objects, output_libname, output_dir=None, libraries=None, 
+            library_dirs=None, runtime_library_dirs=None, export_symbols=None, 
+            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, 
+            target_lang=None): 
+        self.link( 
+            self.SHARED_LIBRARY, objects, output_libname, 
+            output_dir, libraries, library_dirs, runtime_library_dirs, 
+            export_symbols, debug, extra_preargs, extra_postargs, 
+            build_temp, target_lang 
+        ) 
+else: 
+    # Build static libraries everywhere else 
+    libtype = 'static' 
+ 
+    def link_shared_object( 
+            self, objects, output_libname, output_dir=None, libraries=None, 
+            library_dirs=None, runtime_library_dirs=None, export_symbols=None, 
+            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, 
+            target_lang=None): 
+        # XXX we need to either disallow these attrs on Library instances, 
+        # or warn/abort here if set, or something... 
+        # libraries=None, library_dirs=None, runtime_library_dirs=None, 
+        # export_symbols=None, extra_preargs=None, extra_postargs=None, 
+        # build_temp=None 
+ 
+        assert output_dir is None  # distutils build_ext doesn't pass this 
+        output_dir, filename = os.path.split(output_libname) 
+        basename, ext = os.path.splitext(filename) 
+        if self.library_filename("x").startswith('lib'): 
+            # strip 'lib' prefix; this is kludgy if some platform uses 
+            # a different prefix 
+            basename = basename[3:] 
+ 
+        self.create_static_lib( 
+            objects, basename, output_dir, debug, target_lang 
+        ) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/build_py.py b/contrib/python/setuptools/py2/setuptools/command/build_py.py
index b0314fd413..733e283005 100644
--- a/contrib/python/setuptools/py2/setuptools/command/build_py.py
+++ b/contrib/python/setuptools/py2/setuptools/command/build_py.py
@@ -1,103 +1,103 @@
-from glob import glob
-from distutils.util import convert_path
-import distutils.command.build_py as orig
-import os
-import fnmatch
-import textwrap
-import io
-import distutils.errors
-import itertools
-
+from glob import glob 
+from distutils.util import convert_path 
+import distutils.command.build_py as orig 
+import os 
+import fnmatch 
+import textwrap 
+import io 
+import distutils.errors 
+import itertools 
+ 
 from setuptools.extern import six
 from setuptools.extern.six.moves import map, filter, filterfalse
-
-try:
-    from setuptools.lib2to3_ex import Mixin2to3
-except ImportError:
-
-    class Mixin2to3:
-        def run_2to3(self, files, doctests=True):
-            "do nothing"
-
-
-class build_py(orig.build_py, Mixin2to3):
-    """Enhanced 'build_py' command that includes data files with packages
-
-    The data files are specified via a 'package_data' argument to 'setup()'.
-    See 'setuptools.dist.Distribution' for more details.
-
-    Also, this version of the 'build_py' command allows you to specify both
-    'py_modules' and 'packages' in the same setup operation.
-    """
-
-    def finalize_options(self):
-        orig.build_py.finalize_options(self)
-        self.package_data = self.distribution.package_data
-        self.exclude_package_data = (self.distribution.exclude_package_data or
-                                     {})
-        if 'data_files' in self.__dict__:
-            del self.__dict__['data_files']
-        self.__updated_files = []
-        self.__doctests_2to3 = []
-
-    def run(self):
-        """Build modules, packages, and copy data files to build directory"""
-        if not self.py_modules and not self.packages:
-            return
-
-        if self.py_modules:
-            self.build_modules()
-
-        if self.packages:
-            self.build_packages()
-            self.build_package_data()
-
-        self.run_2to3(self.__updated_files, False)
-        self.run_2to3(self.__updated_files, True)
-        self.run_2to3(self.__doctests_2to3, True)
-
-        # Only compile actual .py files, using our base class' idea of what our
-        # output files are.
-        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=0))
-
-    def __getattr__(self, attr):
-        "lazily compute data files"
-        if attr == 'data_files':
-            self.data_files = self._get_data_files()
-            return self.data_files
-        return orig.build_py.__getattr__(self, attr)
-
-    def build_module(self, module, module_file, package):
+ 
+try: 
+    from setuptools.lib2to3_ex import Mixin2to3 
+except ImportError: 
+
+    class Mixin2to3: 
+        def run_2to3(self, files, doctests=True): 
+            "do nothing" 
+ 
+ 
+class build_py(orig.build_py, Mixin2to3): 
+    """Enhanced 'build_py' command that includes data files with packages 
+ 
+    The data files are specified via a 'package_data' argument to 'setup()'. 
+    See 'setuptools.dist.Distribution' for more details. 
+ 
+    Also, this version of the 'build_py' command allows you to specify both 
+    'py_modules' and 'packages' in the same setup operation. 
+    """ 
+ 
+    def finalize_options(self): 
+        orig.build_py.finalize_options(self) 
+        self.package_data = self.distribution.package_data 
+        self.exclude_package_data = (self.distribution.exclude_package_data or 
+                                     {}) 
+        if 'data_files' in self.__dict__: 
+            del self.__dict__['data_files'] 
+        self.__updated_files = [] 
+        self.__doctests_2to3 = [] 
+ 
+    def run(self): 
+        """Build modules, packages, and copy data files to build directory""" 
+        if not self.py_modules and not self.packages: 
+            return 
+ 
+        if self.py_modules: 
+            self.build_modules() 
+ 
+        if self.packages: 
+            self.build_packages() 
+            self.build_package_data() 
+ 
+        self.run_2to3(self.__updated_files, False) 
+        self.run_2to3(self.__updated_files, True) 
+        self.run_2to3(self.__doctests_2to3, True) 
+ 
+        # Only compile actual .py files, using our base class' idea of what our 
+        # output files are. 
+        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=0)) 
+ 
+    def __getattr__(self, attr): 
+        "lazily compute data files" 
+        if attr == 'data_files': 
+            self.data_files = self._get_data_files() 
+            return self.data_files 
+        return orig.build_py.__getattr__(self, attr) 
+ 
+    def build_module(self, module, module_file, package): 
         if six.PY2 and isinstance(package, six.string_types):
             # avoid errors on Python 2 when unicode is passed (#190)
             package = package.split('.')
-        outfile, copied = orig.build_py.build_module(self, module, module_file,
-                                                     package)
-        if copied:
-            self.__updated_files.append(outfile)
-        return outfile, copied
-
-    def _get_data_files(self):
-        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
-        self.analyze_manifest()
-        return list(map(self._get_pkg_data_files, self.packages or ()))
-
-    def _get_pkg_data_files(self, package):
-        # Locate package source directory
-        src_dir = self.get_package_dir(package)
-
-        # Compute package build directory
-        build_dir = os.path.join(*([self.build_lib] + package.split('.')))
-
-        # Strip directory from globbed filenames
-        filenames = [
-            os.path.relpath(file, src_dir)
-            for file in self.find_data_files(package, src_dir)
-        ]
-        return package, src_dir, build_dir, filenames
-
-    def find_data_files(self, package, src_dir):
-        """Return filenames for package's data files in 'src_dir'"""
+        outfile, copied = orig.build_py.build_module(self, module, module_file, 
+                                                     package) 
+        if copied: 
+            self.__updated_files.append(outfile) 
+        return outfile, copied 
+ 
+    def _get_data_files(self): 
+        """Generate list of '(package,src_dir,build_dir,filenames)' tuples""" 
+        self.analyze_manifest() 
+        return list(map(self._get_pkg_data_files, self.packages or ())) 
+ 
+    def _get_pkg_data_files(self, package): 
+        # Locate package source directory 
+        src_dir = self.get_package_dir(package) 
+ 
+        # Compute package build directory 
+        build_dir = os.path.join(*([self.build_lib] + package.split('.'))) 
+ 
+        # Strip directory from globbed filenames 
+        filenames = [ 
+            os.path.relpath(file, src_dir) 
+            for file in self.find_data_files(package, src_dir) 
+        ] 
+        return package, src_dir, build_dir, filenames 
+ 
+    def find_data_files(self, package, src_dir): 
+        """Return filenames for package's data files in 'src_dir'""" 
         patterns = self._get_platform_patterns(
             self.package_data,
             package,
@@ -111,111 +111,111 @@ class build_py(orig.build_py, Mixin2to3):
             self.manifest_files.get(package, []),
             glob_files,
         )
-        return self.exclude_data_files(package, src_dir, files)
-
-    def build_package_data(self):
-        """Copy data files into build directory"""
-        for package, src_dir, build_dir, filenames in self.data_files:
-            for filename in filenames:
-                target = os.path.join(build_dir, filename)
-                self.mkpath(os.path.dirname(target))
-                srcfile = os.path.join(src_dir, filename)
-                outf, copied = self.copy_file(srcfile, target)
-                srcfile = os.path.abspath(srcfile)
-                if (copied and
-                        srcfile in self.distribution.convert_2to3_doctests):
-                    self.__doctests_2to3.append(outf)
-
-    def analyze_manifest(self):
-        self.manifest_files = mf = {}
-        if not self.distribution.include_package_data:
-            return
-        src_dirs = {}
-        for package in self.packages or ():
-            # Locate package source directory
-            src_dirs[assert_relative(self.get_package_dir(package))] = package
-
-        self.run_command('egg_info')
-        ei_cmd = self.get_finalized_command('egg_info')
-        for path in ei_cmd.filelist.files:
-            d, f = os.path.split(assert_relative(path))
-            prev = None
-            oldf = f
-            while d and d != prev and d not in src_dirs:
-                prev = d
-                d, df = os.path.split(d)
-                f = os.path.join(df, f)
-            if d in src_dirs:
-                if path.endswith('.py') and f == oldf:
-                    continue  # it's a module, not data
-                mf.setdefault(src_dirs[d], []).append(path)
-
-    def get_data_files(self):
-        pass  # Lazily compute data files in _get_data_files() function.
-
-    def check_package(self, package, package_dir):
-        """Check namespace packages' __init__ for declare_namespace"""
-        try:
-            return self.packages_checked[package]
-        except KeyError:
-            pass
-
-        init_py = orig.build_py.check_package(self, package, package_dir)
-        self.packages_checked[package] = init_py
-
-        if not init_py or not self.distribution.namespace_packages:
-            return init_py
-
-        for pkg in self.distribution.namespace_packages:
-            if pkg == package or pkg.startswith(package + '.'):
-                break
-        else:
-            return init_py
-
-        with io.open(init_py, 'rb') as f:
-            contents = f.read()
-        if b'declare_namespace' not in contents:
-            raise distutils.errors.DistutilsError(
-                "Namespace package problem: %s is a namespace package, but "
-                "its\n__init__.py does not call declare_namespace()! Please "
-                'fix it.\n(See the setuptools manual under '
-                '"Namespace Packages" for details.)\n"' % (package,)
-            )
-        return init_py
-
-    def initialize_options(self):
-        self.packages_checked = {}
-        orig.build_py.initialize_options(self)
-
-    def get_package_dir(self, package):
-        res = orig.build_py.get_package_dir(self, package)
-        if self.distribution.src_root is not None:
-            return os.path.join(self.distribution.src_root, res)
-        return res
-
-    def exclude_data_files(self, package, src_dir, files):
-        """Filter filenames for package's data files in 'src_dir'"""
+        return self.exclude_data_files(package, src_dir, files) 
+ 
+    def build_package_data(self): 
+        """Copy data files into build directory""" 
+        for package, src_dir, build_dir, filenames in self.data_files: 
+            for filename in filenames: 
+                target = os.path.join(build_dir, filename) 
+                self.mkpath(os.path.dirname(target)) 
+                srcfile = os.path.join(src_dir, filename) 
+                outf, copied = self.copy_file(srcfile, target) 
+                srcfile = os.path.abspath(srcfile) 
+                if (copied and 
+                        srcfile in self.distribution.convert_2to3_doctests): 
+                    self.__doctests_2to3.append(outf) 
+ 
+    def analyze_manifest(self): 
+        self.manifest_files = mf = {} 
+        if not self.distribution.include_package_data: 
+            return 
+        src_dirs = {} 
+        for package in self.packages or (): 
+            # Locate package source directory 
+            src_dirs[assert_relative(self.get_package_dir(package))] = package 
+ 
+        self.run_command('egg_info') 
+        ei_cmd = self.get_finalized_command('egg_info') 
+        for path in ei_cmd.filelist.files: 
+            d, f = os.path.split(assert_relative(path)) 
+            prev = None 
+            oldf = f 
+            while d and d != prev and d not in src_dirs: 
+                prev = d 
+                d, df = os.path.split(d) 
+                f = os.path.join(df, f) 
+            if d in src_dirs: 
+                if path.endswith('.py') and f == oldf: 
+                    continue  # it's a module, not data 
+                mf.setdefault(src_dirs[d], []).append(path) 
+ 
+    def get_data_files(self): 
+        pass  # Lazily compute data files in _get_data_files() function. 
+ 
+    def check_package(self, package, package_dir): 
+        """Check namespace packages' __init__ for declare_namespace""" 
+        try: 
+            return self.packages_checked[package] 
+        except KeyError: 
+            pass 
+ 
+        init_py = orig.build_py.check_package(self, package, package_dir) 
+        self.packages_checked[package] = init_py 
+ 
+        if not init_py or not self.distribution.namespace_packages: 
+            return init_py 
+ 
+        for pkg in self.distribution.namespace_packages: 
+            if pkg == package or pkg.startswith(package + '.'): 
+                break 
+        else: 
+            return init_py 
+ 
+        with io.open(init_py, 'rb') as f: 
+            contents = f.read() 
+        if b'declare_namespace' not in contents: 
+            raise distutils.errors.DistutilsError( 
+                "Namespace package problem: %s is a namespace package, but " 
+                "its\n__init__.py does not call declare_namespace()! Please " 
+                'fix it.\n(See the setuptools manual under ' 
+                '"Namespace Packages" for details.)\n"' % (package,) 
+            ) 
+        return init_py 
+ 
+    def initialize_options(self): 
+        self.packages_checked = {} 
+        orig.build_py.initialize_options(self) 
+ 
+    def get_package_dir(self, package): 
+        res = orig.build_py.get_package_dir(self, package) 
+        if self.distribution.src_root is not None: 
+            return os.path.join(self.distribution.src_root, res) 
+        return res 
+ 
+    def exclude_data_files(self, package, src_dir, files): 
+        """Filter filenames for package's data files in 'src_dir'""" 
         files = list(files)
         patterns = self._get_platform_patterns(
             self.exclude_package_data,
             package,
             src_dir,
-        )
+        ) 
         match_groups = (
             fnmatch.filter(files, pattern)
             for pattern in patterns
-        )
+        ) 
         # flatten the groups of matches into an iterable of matches
         matches = itertools.chain.from_iterable(match_groups)
         bad = set(matches)
         keepers = (
-            fn
-            for fn in files
-            if fn not in bad
+            fn 
+            for fn in files 
+            if fn not in bad 
         )
         # ditch dupes
         return list(_unique_everseen(keepers))
-
+ 
     @staticmethod
     def _get_platform_patterns(spec, package, src_dir):
         """
@@ -233,7 +233,7 @@ class build_py(orig.build_py, Mixin2to3):
             os.path.join(src_dir, convert_path(pattern))
             for pattern in raw_patterns
         )
-
+ 
 
 # from Python docs
 def _unique_everseen(iterable, key=None):
@@ -254,17 +254,17 @@ def _unique_everseen(iterable, key=None):
                 yield element
 
 
-def assert_relative(path):
-    if not os.path.isabs(path):
-        return path
-    from distutils.errors import DistutilsSetupError
-
-    msg = textwrap.dedent("""
-        Error: setup script specifies an absolute path:
-
-            %s
-
-        setup() arguments must *always* be /-separated paths relative to the
-        setup.py directory, *never* absolute paths.
-        """).lstrip() % path
-    raise DistutilsSetupError(msg)
+def assert_relative(path): 
+    if not os.path.isabs(path): 
+        return path 
+    from distutils.errors import DistutilsSetupError 
+ 
+    msg = textwrap.dedent(""" 
+        Error: setup script specifies an absolute path: 
+ 
+            %s 
+ 
+        setup() arguments must *always* be /-separated paths relative to the 
+        setup.py directory, *never* absolute paths. 
+        """).lstrip() % path 
+    raise DistutilsSetupError(msg) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/develop.py b/contrib/python/setuptools/py2/setuptools/command/develop.py
index b561924609..6cb7d37a16 100644
--- a/contrib/python/setuptools/py2/setuptools/command/develop.py
+++ b/contrib/python/setuptools/py2/setuptools/command/develop.py
@@ -1,86 +1,86 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsError, DistutilsOptionError
-import os
-import glob
-import io
-
+from distutils.util import convert_path 
+from distutils import log 
+from distutils.errors import DistutilsError, DistutilsOptionError 
+import os 
+import glob 
+import io 
+ 
 from setuptools.extern import six
-
+ 
 import pkg_resources
-from setuptools.command.easy_install import easy_install
+from setuptools.command.easy_install import easy_install 
 from setuptools import namespaces
-import setuptools
-
+import setuptools 
+ 
 __metaclass__ = type
-
+ 
 
 class develop(namespaces.DevelopInstaller, easy_install):
-    """Set up package for development"""
-
-    description = "install package in 'development mode'"
-
-    user_options = easy_install.user_options + [
-        ("uninstall", "u", "Uninstall this source package"),
-        ("egg-path=", None, "Set the path to be used in the .egg-link file"),
-    ]
-
-    boolean_options = easy_install.boolean_options + ['uninstall']
-
-    command_consumes_arguments = False  # override base
-
-    def run(self):
-        if self.uninstall:
-            self.multi_version = True
-            self.uninstall_link()
+    """Set up package for development""" 
+ 
+    description = "install package in 'development mode'" 
+ 
+    user_options = easy_install.user_options + [ 
+        ("uninstall", "u", "Uninstall this source package"), 
+        ("egg-path=", None, "Set the path to be used in the .egg-link file"), 
+    ] 
+ 
+    boolean_options = easy_install.boolean_options + ['uninstall'] 
+ 
+    command_consumes_arguments = False  # override base 
+ 
+    def run(self): 
+        if self.uninstall: 
+            self.multi_version = True 
+            self.uninstall_link() 
             self.uninstall_namespaces()
-        else:
-            self.install_for_development()
-        self.warn_deprecated_options()
-
-    def initialize_options(self):
-        self.uninstall = None
-        self.egg_path = None
-        easy_install.initialize_options(self)
-        self.setup_path = None
-        self.always_copy_from = '.'  # always copy eggs installed in curdir
-
-    def finalize_options(self):
-        ei = self.get_finalized_command("egg_info")
-        if ei.broken_egg_info:
-            template = "Please rename %r to %r before using 'develop'"
-            args = ei.egg_info, ei.broken_egg_info
-            raise DistutilsError(template % args)
-        self.args = [ei.egg_name]
-
-        easy_install.finalize_options(self)
-        self.expand_basedirs()
-        self.expand_dirs()
-        # pick up setup-dir .egg files only: no .egg-info
-        self.package_index.scan(glob.glob('*.egg'))
-
-        egg_link_fn = ei.egg_name + '.egg-link'
-        self.egg_link = os.path.join(self.install_dir, egg_link_fn)
-        self.egg_base = ei.egg_base
-        if self.egg_path is None:
-            self.egg_path = os.path.abspath(ei.egg_base)
-
+        else: 
+            self.install_for_development() 
+        self.warn_deprecated_options() 
+ 
+    def initialize_options(self): 
+        self.uninstall = None 
+        self.egg_path = None 
+        easy_install.initialize_options(self) 
+        self.setup_path = None 
+        self.always_copy_from = '.'  # always copy eggs installed in curdir 
+ 
+    def finalize_options(self): 
+        ei = self.get_finalized_command("egg_info") 
+        if ei.broken_egg_info: 
+            template = "Please rename %r to %r before using 'develop'" 
+            args = ei.egg_info, ei.broken_egg_info 
+            raise DistutilsError(template % args) 
+        self.args = [ei.egg_name] 
+ 
+        easy_install.finalize_options(self) 
+        self.expand_basedirs() 
+        self.expand_dirs() 
+        # pick up setup-dir .egg files only: no .egg-info 
+        self.package_index.scan(glob.glob('*.egg')) 
+ 
+        egg_link_fn = ei.egg_name + '.egg-link' 
+        self.egg_link = os.path.join(self.install_dir, egg_link_fn) 
+        self.egg_base = ei.egg_base 
+        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))
-        if egg_path != target:
-            raise DistutilsOptionError(
-                "--egg-path must be a relative path from the install"
-                " directory to " + target
-            )
-
-        # Make a distribution for the package's source
+        if egg_path != target: 
+            raise DistutilsOptionError( 
+                "--egg-path must be a relative path from the install" 
+                " directory to " + target 
+            ) 
+ 
+        # Make a distribution for the package's source 
         self.dist = pkg_resources.Distribution(
-            target,
+            target, 
             pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
-            project_name=ei.egg_name
-        )
-
+            project_name=ei.egg_name 
+        ) 
+ 
         self.setup_path = self._resolve_setup_path(
             self.egg_base,
             self.install_dir,
@@ -101,121 +101,121 @@ class develop(namespaces.DevelopInstaller, easy_install):
             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"
+            raise DistutilsOptionError( 
+                "Can't get a consistent path to setup script from" 
                 " installation directory", resolved,
                 pkg_resources.normalize_path(os.curdir))
         return path_to_setup
-
-    def install_for_development(self):
+ 
+    def install_for_development(self): 
         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")
+            # 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 extensions
-            self.reinitialize_command('egg_info', egg_base=build_path)
-            self.run_command('egg_info')
-
-            self.reinitialize_command('build_ext', inplace=0)
-            self.run_command('build_ext')
-
-            # Fixup egg-link and easy-install.pth
-            ei_cmd = self.get_finalized_command("egg_info")
-            self.egg_path = build_path
-            self.dist.location = build_path
-            # XXX
+ 
+            # Build extensions 
+            self.reinitialize_command('egg_info', egg_base=build_path) 
+            self.run_command('egg_info') 
+ 
+            self.reinitialize_command('build_ext', inplace=0) 
+            self.run_command('build_ext') 
+ 
+            # Fixup egg-link and easy-install.pth 
+            ei_cmd = self.get_finalized_command("egg_info") 
+            self.egg_path = build_path 
+            self.dist.location = build_path 
+            # XXX 
             self.dist._provider = pkg_resources.PathMetadata(
                 build_path, ei_cmd.egg_info)
-        else:
-            # Without 2to3 inplace works fine:
-            self.run_command('egg_info')
-
-            # Build extensions in-place
-            self.reinitialize_command('build_ext', inplace=1)
-            self.run_command('build_ext')
-
-        self.install_site_py()  # ensure that target dir is site-safe
-        if setuptools.bootstrap_install_from:
-            self.easy_install(setuptools.bootstrap_install_from)
-            setuptools.bootstrap_install_from = None
-
+        else: 
+            # Without 2to3 inplace works fine: 
+            self.run_command('egg_info') 
+ 
+            # Build extensions in-place 
+            self.reinitialize_command('build_ext', inplace=1) 
+            self.run_command('build_ext') 
+ 
+        self.install_site_py()  # ensure that target dir is site-safe 
+        if setuptools.bootstrap_install_from: 
+            self.easy_install(setuptools.bootstrap_install_from) 
+            setuptools.bootstrap_install_from = None 
+ 
         self.install_namespaces()
 
-        # create an .egg-link in the installation dir, pointing to our egg
-        log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
-        if not self.dry_run:
-            with open(self.egg_link, "w") as f:
-                f.write(self.egg_path + "\n" + self.setup_path)
-        # postprocess the installed distro, fixing up .pth, installing scripts,
-        # and handling requirements
-        self.process_distribution(None, self.dist, not self.no_deps)
-
-    def uninstall_link(self):
-        if os.path.exists(self.egg_link):
-            log.info("Removing %s (link to %s)", self.egg_link, self.egg_base)
-            egg_link_file = open(self.egg_link)
-            contents = [line.rstrip() for line in egg_link_file]
-            egg_link_file.close()
-            if contents not in ([self.egg_path],
-                                [self.egg_path, self.setup_path]):
-                log.warn("Link points to %s: uninstall aborted", contents)
-                return
-            if not self.dry_run:
-                os.unlink(self.egg_link)
-        if not self.dry_run:
-            self.update_pth(self.dist)  # remove any .pth link to us
-        if self.distribution.scripts:
-            # XXX should also check for entry point scripts!
-            log.warn("Note: you must uninstall or replace scripts manually!")
-
-    def install_egg_scripts(self, dist):
-        if dist is not self.dist:
-            # Installing a dependency, so fall back to normal behavior
-            return easy_install.install_egg_scripts(self, dist)
-
-        # create wrapper scripts in the script dir, pointing to dist.scripts
-
-        # new-style...
-        self.install_wrapper_scripts(dist)
-
-        # ...and old-style
-        for script_name in self.distribution.scripts or []:
-            script_path = os.path.abspath(convert_path(script_name))
-            script_name = os.path.basename(script_path)
-            with io.open(script_path) as strm:
-                script_text = strm.read()
-            self.install_script(dist, script_name, script_text, script_path)
-
-    def install_wrapper_scripts(self, dist):
-        dist = VersionlessRequirement(dist)
-        return easy_install.install_wrapper_scripts(self, dist)
-
-
+        # create an .egg-link in the installation dir, pointing to our egg 
+        log.info("Creating %s (link to %s)", self.egg_link, self.egg_base) 
+        if not self.dry_run: 
+            with open(self.egg_link, "w") as f: 
+                f.write(self.egg_path + "\n" + self.setup_path) 
+        # postprocess the installed distro, fixing up .pth, installing scripts, 
+        # and handling requirements 
+        self.process_distribution(None, self.dist, not self.no_deps) 
+ 
+    def uninstall_link(self): 
+        if os.path.exists(self.egg_link): 
+            log.info("Removing %s (link to %s)", self.egg_link, self.egg_base) 
+            egg_link_file = open(self.egg_link) 
+            contents = [line.rstrip() for line in egg_link_file] 
+            egg_link_file.close() 
+            if contents not in ([self.egg_path], 
+                                [self.egg_path, self.setup_path]): 
+                log.warn("Link points to %s: uninstall aborted", contents) 
+                return 
+            if not self.dry_run: 
+                os.unlink(self.egg_link) 
+        if not self.dry_run: 
+            self.update_pth(self.dist)  # remove any .pth link to us 
+        if self.distribution.scripts: 
+            # XXX should also check for entry point scripts! 
+            log.warn("Note: you must uninstall or replace scripts manually!") 
+ 
+    def install_egg_scripts(self, dist): 
+        if dist is not self.dist: 
+            # Installing a dependency, so fall back to normal behavior 
+            return easy_install.install_egg_scripts(self, dist) 
+ 
+        # create wrapper scripts in the script dir, pointing to dist.scripts 
+ 
+        # new-style... 
+        self.install_wrapper_scripts(dist) 
+ 
+        # ...and old-style 
+        for script_name in self.distribution.scripts or []: 
+            script_path = os.path.abspath(convert_path(script_name)) 
+            script_name = os.path.basename(script_path) 
+            with io.open(script_path) as strm: 
+                script_text = strm.read() 
+            self.install_script(dist, script_name, script_text, script_path) 
+ 
+    def install_wrapper_scripts(self, dist): 
+        dist = VersionlessRequirement(dist) 
+        return easy_install.install_wrapper_scripts(self, dist) 
+ 
+ 
 class VersionlessRequirement:
-    """
-    Adapt a pkg_resources.Distribution to simply return the project
-    name as the 'requirement' so that scripts will work across
-    multiple versions.
-
+    """ 
+    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
-    >>> dist = Distribution(project_name='foo', version='1.0')
-    >>> str(dist.as_requirement())
-    'foo==1.0'
-    >>> adapted_dist = VersionlessRequirement(dist)
-    >>> str(adapted_dist.as_requirement())
-    'foo'
-    """
-
-    def __init__(self, dist):
-        self.__dist = dist
-
-    def __getattr__(self, name):
-        return getattr(self.__dist, name)
-
-    def as_requirement(self):
-        return self.project_name
+    >>> dist = Distribution(project_name='foo', version='1.0') 
+    >>> str(dist.as_requirement()) 
+    'foo==1.0' 
+    >>> adapted_dist = VersionlessRequirement(dist) 
+    >>> str(adapted_dist.as_requirement()) 
+    'foo' 
+    """ 
+
+    def __init__(self, dist): 
+        self.__dist = dist 
+ 
+    def __getattr__(self, name): 
+        return getattr(self.__dist, name) 
+ 
+    def as_requirement(self): 
+        return self.project_name 
diff --git a/contrib/python/setuptools/py2/setuptools/command/easy_install.py b/contrib/python/setuptools/py2/setuptools/command/easy_install.py
index 426301d6f3..037a85a5f4 100644
--- a/contrib/python/setuptools/py2/setuptools/command/easy_install.py
+++ b/contrib/python/setuptools/py2/setuptools/command/easy_install.py
@@ -1,46 +1,46 @@
-#!/usr/bin/env python
-"""
-Easy Install
-------------
-
-A tool for doing automatic download/extract/build of distutils-based Python
-packages.  For detailed documentation, see the accompanying EasyInstall.txt
-file, or visit the `EasyInstall home page`__.
-
+#!/usr/bin/env python 
+""" 
+Easy Install 
+------------ 
+ 
+A tool for doing automatic download/extract/build of distutils-based Python 
+packages.  For detailed documentation, see the accompanying EasyInstall.txt 
+file, or visit the `EasyInstall home page`__. 
+ 
 __ https://setuptools.readthedocs.io/en/latest/easy_install.html
-
-"""
-
-from glob import glob
-from distutils.util import get_platform
-from distutils.util import convert_path, subst_vars
+ 
+""" 
+ 
+from glob import glob 
+from distutils.util import get_platform 
+from distutils.util import convert_path, subst_vars 
 from distutils.errors import (
     DistutilsArgError, DistutilsOptionError,
     DistutilsError, DistutilsPlatformError,
 )
-from distutils.command.install import INSTALL_SCHEMES, SCHEME_KEYS
-from distutils import log, dir_util
-from distutils.command.build_scripts import first_line_re
-from distutils.spawn import find_executable
-import sys
-import os
-import zipimport
-import shutil
-import tempfile
-import zipfile
-import re
-import stat
-import random
-import textwrap
-import warnings
-import site
-import struct
-import contextlib
-import subprocess
-import shlex
-import io
-
-
+from distutils.command.install import INSTALL_SCHEMES, SCHEME_KEYS 
+from distutils import log, dir_util 
+from distutils.command.build_scripts import first_line_re 
+from distutils.spawn import find_executable 
+import sys 
+import os 
+import zipimport 
+import shutil 
+import tempfile 
+import zipfile 
+import re 
+import stat 
+import random 
+import textwrap 
+import warnings 
+import site 
+import struct 
+import contextlib 
+import subprocess 
+import shlex 
+import io 
+ 
+ 
 from sysconfig import get_config_vars, get_path
 
 from setuptools import SetuptoolsDeprecationWarning
@@ -48,358 +48,358 @@ 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 import Command 
+from setuptools.sandbox import run_setup 
 from setuptools.py27compat import rmtree_safe
-from setuptools.command import setopt
-from setuptools.archive_util import unpack_archive
+from setuptools.command import setopt 
+from setuptools.archive_util import unpack_archive 
 from setuptools.package_index import (
     PackageIndex, parse_requirement_arg, URL_SCHEME,
 )
-from setuptools.command import bdist_egg, egg_info
+from setuptools.command import bdist_egg, egg_info 
 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,
-)
+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
 
-# Turn on PEP440Warnings
-warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)
-
-__all__ = [
-    'samefile', 'easy_install', 'PthDistributions', 'extract_wininst_cfg',
-    'main', 'get_exe_prefixes',
-]
-
-
-def is_64bit():
-    return struct.calcsize("P") == 8
-
-
-def samefile(p1, p2):
+# Turn on PEP440Warnings 
+warnings.filterwarnings("default", category=pkg_resources.PEP440Warning) 
+ 
+__all__ = [ 
+    'samefile', 'easy_install', 'PthDistributions', 'extract_wininst_cfg', 
+    'main', 'get_exe_prefixes', 
+] 
+ 
+ 
+def is_64bit(): 
+    return struct.calcsize("P") == 8 
+ 
+ 
+def samefile(p1, p2): 
     """
     Determine if two paths reference the same file.
 
     Augments os.path.samefile to work on Windows and
     suppresses errors if the path doesn't exist.
     """
-    both_exist = os.path.exists(p1) and os.path.exists(p2)
-    use_samefile = hasattr(os.path, 'samefile') and both_exist
-    if use_samefile:
-        return os.path.samefile(p1, p2)
-    norm_p1 = os.path.normpath(os.path.normcase(p1))
-    norm_p2 = os.path.normpath(os.path.normcase(p2))
-    return norm_p1 == norm_p2
-
-
-if six.PY2:
+    both_exist = os.path.exists(p1) and os.path.exists(p2) 
+    use_samefile = hasattr(os.path, 'samefile') and both_exist 
+    if use_samefile: 
+        return os.path.samefile(p1, p2) 
+    norm_p1 = os.path.normpath(os.path.normcase(p1)) 
+    norm_p2 = os.path.normpath(os.path.normcase(p2)) 
+    return norm_p1 == norm_p2 
+ 
+ 
+if six.PY2: 
 
     def _to_bytes(s):
-        return s
-
-    def isascii(s):
-        try:
-            six.text_type(s, 'ascii')
-            return True
-        except UnicodeError:
-            return False
-else:
+        return s 
+ 
+    def isascii(s): 
+        try: 
+            six.text_type(s, 'ascii') 
+            return True 
+        except UnicodeError: 
+            return False 
+else: 
 
     def _to_bytes(s):
         return s.encode('utf8')
-
-    def isascii(s):
-        try:
-            s.encode('ascii')
-            return True
-        except UnicodeError:
-            return False
-
-
+ 
+    def isascii(s): 
+        try: 
+            s.encode('ascii') 
+            return True 
+        except UnicodeError: 
+            return False 
+ 
+ 
 _one_liner = lambda text: textwrap.dedent(text).strip().replace('\n', '; ')
 
 
-class easy_install(Command):
-    """Manage a download/build/install process"""
-    description = "Find/get/install Python packages"
-    command_consumes_arguments = True
-
-    user_options = [
-        ('prefix=', None, "installation prefix"),
-        ("zip-ok", "z", "install package as a zipfile"),
-        ("multi-version", "m", "make apps have to require() a version"),
-        ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
-        ("install-dir=", "d", "install package to DIR"),
-        ("script-dir=", "s", "install scripts to DIR"),
-        ("exclude-scripts", "x", "Don't install scripts"),
-        ("always-copy", "a", "Copy all needed packages to install dir"),
-        ("index-url=", "i", "base URL of Python Package Index"),
-        ("find-links=", "f", "additional URL(s) to search for packages"),
-        ("build-directory=", "b",
-         "download/extract/build in DIR; keep the results"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-        ('record=', None,
-         "filename in which to record list of installed files"),
-        ('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
-        ('site-dirs=', 'S', "list of directories where .pth files work"),
-        ('editable', 'e', "Install specified packages in editable form"),
-        ('no-deps', 'N', "don't install dependencies"),
-        ('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
-        ('local-snapshots-ok', 'l',
-         "allow building eggs from local checkouts"),
-        ('version', None, "print version information and exit"),
-        ('no-find-links', None,
-         "Don't load find-links defined in packages being installed")
-    ]
-    boolean_options = [
-        'zip-ok', 'multi-version', 'exclude-scripts', 'upgrade', 'always-copy',
-        'editable',
-        'no-deps', 'local-snapshots-ok', 'version'
-    ]
-
-    if site.ENABLE_USER_SITE:
-        help_msg = "install in user site-package '%s'" % site.USER_SITE
-        user_options.append(('user', None, help_msg))
-        boolean_options.append('user')
-
-    negative_opt = {'always-unzip': 'zip-ok'}
-    create_index = PackageIndex
-
-    def initialize_options(self):
-        # the --user option seems to be an opt-in one,
-        # so the default should be False.
-        self.user = 0
-        self.zip_ok = self.local_snapshots_ok = None
-        self.install_dir = self.script_dir = self.exclude_scripts = None
-        self.index_url = None
-        self.find_links = None
-        self.build_directory = None
-        self.args = None
-        self.optimize = self.record = None
-        self.upgrade = self.always_copy = self.multi_version = None
-        self.editable = self.no_deps = self.allow_hosts = None
-        self.root = self.prefix = self.no_report = None
-        self.version = None
-        self.install_purelib = None  # for pure module distributions
-        self.install_platlib = None  # non-pure (dists w/ extensions)
-        self.install_headers = None  # for C/C++ headers
-        self.install_lib = None  # set to either purelib or platlib
-        self.install_scripts = None
-        self.install_data = None
-        self.install_base = None
-        self.install_platbase = None
-        if site.ENABLE_USER_SITE:
-            self.install_userbase = site.USER_BASE
-            self.install_usersite = site.USER_SITE
-        else:
-            self.install_userbase = None
-            self.install_usersite = None
-        self.no_find_links = None
-
-        # Options not specifiable via command line
-        self.package_index = None
-        self.pth_file = self.always_copy_from = None
-        self.site_dirs = None
-        self.installed_projects = {}
-        self.sitepy_installed = False
-        # Always read easy_install options, even if we are subclassed, or have
-        # an independent instance created.  This ensures that defaults will
-        # always come from the standard configuration file(s)' "easy_install"
-        # section, even if this is a "develop" or "install" command, or some
-        # other embedding.
-        self._dry_run = None
-        self.verbose = self.distribution.verbose
-        self.distribution._set_command_options(
-            self, self.distribution.get_option_dict('easy_install')
-        )
-
-    def delete_blockers(self, blockers):
-        extant_blockers = (
-            filename for filename in blockers
-            if os.path.exists(filename) or os.path.islink(filename)
-        )
-        list(map(self._delete_path, extant_blockers))
-
-    def _delete_path(self, path):
-        log.info("Deleting %s", path)
-        if self.dry_run:
-            return
-
-        is_tree = os.path.isdir(path) and not os.path.islink(path)
-        remover = rmtree if is_tree else os.unlink
-        remover(path)
-
-    @staticmethod
-    def _render_version():
-        """
-        Render the Setuptools version and installation details, then exit.
-        """
+class easy_install(Command): 
+    """Manage a download/build/install process""" 
+    description = "Find/get/install Python packages" 
+    command_consumes_arguments = True 
+ 
+    user_options = [ 
+        ('prefix=', None, "installation prefix"), 
+        ("zip-ok", "z", "install package as a zipfile"), 
+        ("multi-version", "m", "make apps have to require() a version"), 
+        ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"), 
+        ("install-dir=", "d", "install package to DIR"), 
+        ("script-dir=", "s", "install scripts to DIR"), 
+        ("exclude-scripts", "x", "Don't install scripts"), 
+        ("always-copy", "a", "Copy all needed packages to install dir"), 
+        ("index-url=", "i", "base URL of Python Package Index"), 
+        ("find-links=", "f", "additional URL(s) to search for packages"), 
+        ("build-directory=", "b", 
+         "download/extract/build in DIR; keep the results"), 
+        ('optimize=', 'O', 
+         "also compile with optimization: -O1 for \"python -O\", " 
+         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"), 
+        ('record=', None, 
+         "filename in which to record list of installed files"), 
+        ('always-unzip', 'Z', "don't install as a zipfile, no matter what"), 
+        ('site-dirs=', 'S', "list of directories where .pth files work"), 
+        ('editable', 'e', "Install specified packages in editable form"), 
+        ('no-deps', 'N', "don't install dependencies"), 
+        ('allow-hosts=', 'H', "pattern(s) that hostnames must match"), 
+        ('local-snapshots-ok', 'l', 
+         "allow building eggs from local checkouts"), 
+        ('version', None, "print version information and exit"), 
+        ('no-find-links', None, 
+         "Don't load find-links defined in packages being installed") 
+    ] 
+    boolean_options = [ 
+        'zip-ok', 'multi-version', 'exclude-scripts', 'upgrade', 'always-copy', 
+        'editable', 
+        'no-deps', 'local-snapshots-ok', 'version' 
+    ] 
+ 
+    if site.ENABLE_USER_SITE: 
+        help_msg = "install in user site-package '%s'" % site.USER_SITE 
+        user_options.append(('user', None, help_msg)) 
+        boolean_options.append('user') 
+ 
+    negative_opt = {'always-unzip': 'zip-ok'} 
+    create_index = PackageIndex 
+ 
+    def initialize_options(self): 
+        # the --user option seems to be an opt-in one, 
+        # so the default should be False. 
+        self.user = 0 
+        self.zip_ok = self.local_snapshots_ok = None 
+        self.install_dir = self.script_dir = self.exclude_scripts = None 
+        self.index_url = None 
+        self.find_links = None 
+        self.build_directory = None 
+        self.args = None 
+        self.optimize = self.record = None 
+        self.upgrade = self.always_copy = self.multi_version = None 
+        self.editable = self.no_deps = self.allow_hosts = None 
+        self.root = self.prefix = self.no_report = None 
+        self.version = None 
+        self.install_purelib = None  # for pure module distributions 
+        self.install_platlib = None  # non-pure (dists w/ extensions) 
+        self.install_headers = None  # for C/C++ headers 
+        self.install_lib = None  # set to either purelib or platlib 
+        self.install_scripts = None 
+        self.install_data = None 
+        self.install_base = None 
+        self.install_platbase = None 
+        if site.ENABLE_USER_SITE: 
+            self.install_userbase = site.USER_BASE 
+            self.install_usersite = site.USER_SITE 
+        else: 
+            self.install_userbase = None 
+            self.install_usersite = None 
+        self.no_find_links = None 
+ 
+        # Options not specifiable via command line 
+        self.package_index = None 
+        self.pth_file = self.always_copy_from = None 
+        self.site_dirs = None 
+        self.installed_projects = {} 
+        self.sitepy_installed = False 
+        # Always read easy_install options, even if we are subclassed, or have 
+        # an independent instance created.  This ensures that defaults will 
+        # always come from the standard configuration file(s)' "easy_install" 
+        # section, even if this is a "develop" or "install" command, or some 
+        # other embedding. 
+        self._dry_run = None 
+        self.verbose = self.distribution.verbose 
+        self.distribution._set_command_options( 
+            self, self.distribution.get_option_dict('easy_install') 
+        ) 
+ 
+    def delete_blockers(self, blockers): 
+        extant_blockers = ( 
+            filename for filename in blockers 
+            if os.path.exists(filename) or os.path.islink(filename) 
+        ) 
+        list(map(self._delete_path, extant_blockers)) 
+ 
+    def _delete_path(self, path): 
+        log.info("Deleting %s", path) 
+        if self.dry_run: 
+            return 
+ 
+        is_tree = os.path.isdir(path) and not os.path.islink(path) 
+        remover = rmtree if is_tree else os.unlink 
+        remover(path) 
+ 
+    @staticmethod 
+    def _render_version(): 
+        """ 
+        Render the Setuptools version and installation details, then exit. 
+        """ 
         ver = '{}.{}'.format(*sys.version_info)
-        dist = get_distribution('setuptools')
-        tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})'
-        print(tmpl.format(**locals()))
-        raise SystemExit()
-
-    def finalize_options(self):
-        self.version and self._render_version()
-
-        py_version = sys.version.split()[0]
-        prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix')
-
-        self.config_vars = {
-            'dist_name': self.distribution.get_name(),
-            'dist_version': self.distribution.get_version(),
-            'dist_fullname': self.distribution.get_fullname(),
-            'py_version': py_version,
-            'py_version_short': py_version[0:3],
-            'py_version_nodot': py_version[0] + py_version[2],
-            'sys_prefix': prefix,
-            'prefix': prefix,
-            'sys_exec_prefix': exec_prefix,
-            'exec_prefix': exec_prefix,
-            # Only python 3.2+ has abiflags
-            'abiflags': getattr(sys, 'abiflags', ''),
-        }
-
-        if site.ENABLE_USER_SITE:
-            self.config_vars['userbase'] = self.install_userbase
-            self.config_vars['usersite'] = self.install_usersite
-
-        self._fix_install_dir_for_user_site()
-
-        self.expand_basedirs()
-        self.expand_dirs()
-
+        dist = get_distribution('setuptools') 
+        tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})' 
+        print(tmpl.format(**locals())) 
+        raise SystemExit() 
+ 
+    def finalize_options(self): 
+        self.version and self._render_version() 
+ 
+        py_version = sys.version.split()[0] 
+        prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix') 
+ 
+        self.config_vars = { 
+            'dist_name': self.distribution.get_name(), 
+            'dist_version': self.distribution.get_version(), 
+            'dist_fullname': self.distribution.get_fullname(), 
+            'py_version': py_version, 
+            'py_version_short': py_version[0:3], 
+            'py_version_nodot': py_version[0] + py_version[2], 
+            'sys_prefix': prefix, 
+            'prefix': prefix, 
+            'sys_exec_prefix': exec_prefix, 
+            'exec_prefix': exec_prefix, 
+            # Only python 3.2+ has abiflags 
+            'abiflags': getattr(sys, 'abiflags', ''), 
+        } 
+ 
+        if site.ENABLE_USER_SITE: 
+            self.config_vars['userbase'] = self.install_userbase 
+            self.config_vars['usersite'] = self.install_usersite 
+ 
+        self._fix_install_dir_for_user_site() 
+ 
+        self.expand_basedirs() 
+        self.expand_dirs() 
+ 
         self._expand(
             'install_dir', 'script_dir', 'build_directory',
             'site_dirs',
         )
-        # If a non-default installation directory was specified, default the
-        # script directory to match it.
-        if self.script_dir is None:
-            self.script_dir = self.install_dir
-
-        if self.no_find_links is None:
-            self.no_find_links = False
-
-        # Let install_dir get set by install_lib command, which in turn
-        # gets its info from the install command, and takes into account
-        # --prefix and --home and all that other crud.
-        self.set_undefined_options(
-            'install_lib', ('install_dir', 'install_dir')
-        )
-        # Likewise, set default script_dir from 'install_scripts.install_dir'
-        self.set_undefined_options(
-            'install_scripts', ('install_dir', 'script_dir')
-        )
-
-        if self.user and self.install_purelib:
-            self.install_dir = self.install_purelib
-            self.script_dir = self.install_scripts
-        # default --record from the install command
-        self.set_undefined_options('install', ('record', 'record'))
-        # Should this be moved to the if statement below? It's not used
-        # elsewhere
-        normpath = map(normalize_path, sys.path)
-        self.all_site_dirs = get_site_dirs()
-        if self.site_dirs is not None:
-            site_dirs = [
-                os.path.expanduser(s.strip()) for s in
-                self.site_dirs.split(',')
-            ]
-            for d in site_dirs:
-                if not os.path.isdir(d):
-                    log.warn("%s (in --site-dirs) does not exist", d)
-                elif normalize_path(d) not in normpath:
-                    raise DistutilsOptionError(
-                        d + " (in --site-dirs) is not on sys.path"
-                    )
-                else:
-                    self.all_site_dirs.append(normalize_path(d))
-        if not self.editable:
-            self.check_site_dir()
+        # If a non-default installation directory was specified, default the 
+        # script directory to match it. 
+        if self.script_dir is None: 
+            self.script_dir = self.install_dir 
+ 
+        if self.no_find_links is None: 
+            self.no_find_links = False 
+ 
+        # Let install_dir get set by install_lib command, which in turn 
+        # gets its info from the install command, and takes into account 
+        # --prefix and --home and all that other crud. 
+        self.set_undefined_options( 
+            'install_lib', ('install_dir', 'install_dir') 
+        ) 
+        # Likewise, set default script_dir from 'install_scripts.install_dir' 
+        self.set_undefined_options( 
+            'install_scripts', ('install_dir', 'script_dir') 
+        ) 
+ 
+        if self.user and self.install_purelib: 
+            self.install_dir = self.install_purelib 
+            self.script_dir = self.install_scripts 
+        # default --record from the install command 
+        self.set_undefined_options('install', ('record', 'record')) 
+        # Should this be moved to the if statement below? It's not used 
+        # elsewhere 
+        normpath = map(normalize_path, sys.path) 
+        self.all_site_dirs = get_site_dirs() 
+        if self.site_dirs is not None: 
+            site_dirs = [ 
+                os.path.expanduser(s.strip()) for s in 
+                self.site_dirs.split(',') 
+            ] 
+            for d in site_dirs: 
+                if not os.path.isdir(d): 
+                    log.warn("%s (in --site-dirs) does not exist", d) 
+                elif normalize_path(d) not in normpath: 
+                    raise DistutilsOptionError( 
+                        d + " (in --site-dirs) is not on sys.path" 
+                    ) 
+                else: 
+                    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.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:
-                self.shadow_path.insert(0, path_item)
-
-        if self.allow_hosts is not None:
-            hosts = [s.strip() for s in self.allow_hosts.split(',')]
-        else:
-            hosts = ['*']
-        if self.package_index is None:
-            self.package_index = self.create_index(
-                self.index_url, search_path=self.shadow_path, hosts=hosts,
-            )
-        self.local_index = Environment(self.shadow_path + sys.path)
-
-        if self.find_links is not None:
-            if isinstance(self.find_links, six.string_types):
-                self.find_links = self.find_links.split()
-        else:
-            self.find_links = []
-        if self.local_snapshots_ok:
-            self.package_index.scan_egg_links(self.shadow_path + sys.path)
-        if not self.no_find_links:
-            self.package_index.add_find_links(self.find_links)
-        self.set_undefined_options('install_lib', ('optimize', 'optimize'))
-        if not isinstance(self.optimize, int):
-            try:
-                self.optimize = int(self.optimize)
-                if not (0 <= self.optimize <= 2):
-                    raise ValueError
-            except ValueError:
-                raise DistutilsOptionError("--optimize must be 0, 1, or 2")
-
-        if self.editable and not self.build_directory:
-            raise DistutilsArgError(
-                "Must specify a build directory (-b) when using --editable"
-            )
-        if not self.args:
-            raise DistutilsArgError(
-                "No urls, filenames, or requirements specified (see --help)")
-
-        self.outputs = []
-
-    def _fix_install_dir_for_user_site(self):
-        """
-        Fix the install_dir if "--user" was used.
-        """
-        if not self.user or not site.ENABLE_USER_SITE:
-            return
-
-        self.create_home_path()
-        if self.install_userbase is None:
-            msg = "User base directory is not specified"
-            raise DistutilsPlatformError(msg)
-        self.install_base = self.install_platbase = self.install_userbase
-        scheme_name = os.name.replace('posix', 'unix') + '_user'
-        self.select_scheme(scheme_name)
-
-    def _expand_attrs(self, attrs):
-        for attr in attrs:
-            val = getattr(self, attr)
-            if val is not None:
-                if os.name == 'posix' or os.name == 'nt':
-                    val = os.path.expanduser(val)
-                val = subst_vars(val, self.config_vars)
-                setattr(self, attr, val)
-
-    def expand_basedirs(self):
-        """Calls `os.path.expanduser` on install_base, install_platbase and
-        root."""
-        self._expand_attrs(['install_base', 'install_platbase', 'root'])
-
-    def expand_dirs(self):
-        """Calls `os.path.expanduser` on install dirs."""
+        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: 
+                self.shadow_path.insert(0, path_item) 
+ 
+        if self.allow_hosts is not None: 
+            hosts = [s.strip() for s in self.allow_hosts.split(',')] 
+        else: 
+            hosts = ['*'] 
+        if self.package_index is None: 
+            self.package_index = self.create_index( 
+                self.index_url, search_path=self.shadow_path, hosts=hosts, 
+            ) 
+        self.local_index = Environment(self.shadow_path + sys.path) 
+ 
+        if self.find_links is not None: 
+            if isinstance(self.find_links, six.string_types): 
+                self.find_links = self.find_links.split() 
+        else: 
+            self.find_links = [] 
+        if self.local_snapshots_ok: 
+            self.package_index.scan_egg_links(self.shadow_path + sys.path) 
+        if not self.no_find_links: 
+            self.package_index.add_find_links(self.find_links) 
+        self.set_undefined_options('install_lib', ('optimize', 'optimize')) 
+        if not isinstance(self.optimize, int): 
+            try: 
+                self.optimize = int(self.optimize) 
+                if not (0 <= self.optimize <= 2): 
+                    raise ValueError 
+            except ValueError: 
+                raise DistutilsOptionError("--optimize must be 0, 1, or 2") 
+ 
+        if self.editable and not self.build_directory: 
+            raise DistutilsArgError( 
+                "Must specify a build directory (-b) when using --editable" 
+            ) 
+        if not self.args: 
+            raise DistutilsArgError( 
+                "No urls, filenames, or requirements specified (see --help)") 
+ 
+        self.outputs = [] 
+ 
+    def _fix_install_dir_for_user_site(self): 
+        """ 
+        Fix the install_dir if "--user" was used. 
+        """ 
+        if not self.user or not site.ENABLE_USER_SITE: 
+            return 
+ 
+        self.create_home_path() 
+        if self.install_userbase is None: 
+            msg = "User base directory is not specified" 
+            raise DistutilsPlatformError(msg) 
+        self.install_base = self.install_platbase = self.install_userbase 
+        scheme_name = os.name.replace('posix', 'unix') + '_user' 
+        self.select_scheme(scheme_name) 
+ 
+    def _expand_attrs(self, attrs): 
+        for attr in attrs: 
+            val = getattr(self, attr) 
+            if val is not None: 
+                if os.name == 'posix' or os.name == 'nt': 
+                    val = os.path.expanduser(val) 
+                val = subst_vars(val, self.config_vars) 
+                setattr(self, attr, val) 
+ 
+    def expand_basedirs(self): 
+        """Calls `os.path.expanduser` on install_base, install_platbase and 
+        root.""" 
+        self._expand_attrs(['install_base', 'install_platbase', 'root']) 
+ 
+    def expand_dirs(self): 
+        """Calls `os.path.expanduser` on install dirs.""" 
         dirs = [
             'install_purelib',
             'install_platlib',
@@ -409,7 +409,7 @@ class easy_install(Command):
             'install_data',
         ]
         self._expand_attrs(dirs)
-
+ 
     def run(self, show_deprecation=True):
         if show_deprecation:
             self.announce(
@@ -417,228 +417,228 @@ class easy_install(Command):
                 "and will be removed in a future version."
                 , log.WARN,
             )
-        if self.verbose != self.distribution.verbose:
-            log.set_verbosity(self.verbose)
-        try:
-            for spec in self.args:
-                self.easy_install(spec, not self.no_deps)
-            if self.record:
-                outputs = self.outputs
-                if self.root:  # strip any package prefix
-                    root_len = len(self.root)
-                    for counter in range(len(outputs)):
-                        outputs[counter] = outputs[counter][root_len:]
-                from distutils import file_util
-
-                self.execute(
-                    file_util.write_file, (self.record, outputs),
-                    "writing list of installed files to '%s'" %
-                    self.record
-                )
-            self.warn_deprecated_options()
-        finally:
-            log.set_verbosity(self.distribution.verbose)
-
-    def pseudo_tempname(self):
-        """Return a pseudo-tempname base in the install directory.
-        This code is intentionally naive; if a malicious party can write to
-        the target directory you're already in deep doodoo.
-        """
-        try:
-            pid = os.getpid()
+        if self.verbose != self.distribution.verbose: 
+            log.set_verbosity(self.verbose) 
+        try: 
+            for spec in self.args: 
+                self.easy_install(spec, not self.no_deps) 
+            if self.record: 
+                outputs = self.outputs 
+                if self.root:  # strip any package prefix 
+                    root_len = len(self.root) 
+                    for counter in range(len(outputs)): 
+                        outputs[counter] = outputs[counter][root_len:] 
+                from distutils import file_util 
+ 
+                self.execute( 
+                    file_util.write_file, (self.record, outputs), 
+                    "writing list of installed files to '%s'" % 
+                    self.record 
+                ) 
+            self.warn_deprecated_options() 
+        finally: 
+            log.set_verbosity(self.distribution.verbose) 
+ 
+    def pseudo_tempname(self): 
+        """Return a pseudo-tempname base in the install directory. 
+        This code is intentionally naive; if a malicious party can write to 
+        the target directory you're already in deep doodoo. 
+        """ 
+        try: 
+            pid = os.getpid() 
         except Exception:
-            pid = random.randint(0, sys.maxsize)
-        return os.path.join(self.install_dir, "test-easy-install-%s" % pid)
-
-    def warn_deprecated_options(self):
-        pass
-
-    def check_site_dir(self):
-        """Verify that self.install_dir is .pth-capable dir, if needed"""
-
-        instdir = normalize_path(self.install_dir)
-        pth_file = os.path.join(instdir, 'easy-install.pth')
-
-        # Is it a configured, PYTHONPATH, implicit, or explicit site dir?
-        is_site_dir = instdir in self.all_site_dirs
-
-        if not is_site_dir and not self.multi_version:
-            # No?  Then directly test whether it does .pth file processing
-            is_site_dir = self.check_pth_processing()
-        else:
-            # make sure we can write to target dir
-            testfile = self.pseudo_tempname() + '.write-test'
-            test_exists = os.path.exists(testfile)
-            try:
-                if test_exists:
-                    os.unlink(testfile)
-                open(testfile, 'w').close()
-                os.unlink(testfile)
-            except (OSError, IOError):
-                self.cant_write_to_target()
-
-        if not is_site_dir and not self.multi_version:
-            # Can't install non-multi to non-site dir
-            raise DistutilsError(self.no_default_version_msg())
-
-        if is_site_dir:
-            if self.pth_file is None:
-                self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
-        else:
-            self.pth_file = None
-
+            pid = random.randint(0, sys.maxsize) 
+        return os.path.join(self.install_dir, "test-easy-install-%s" % pid) 
+ 
+    def warn_deprecated_options(self): 
+        pass 
+ 
+    def check_site_dir(self): 
+        """Verify that self.install_dir is .pth-capable dir, if needed""" 
+ 
+        instdir = normalize_path(self.install_dir) 
+        pth_file = os.path.join(instdir, 'easy-install.pth') 
+ 
+        # Is it a configured, PYTHONPATH, implicit, or explicit site dir? 
+        is_site_dir = instdir in self.all_site_dirs 
+ 
+        if not is_site_dir and not self.multi_version: 
+            # No?  Then directly test whether it does .pth file processing 
+            is_site_dir = self.check_pth_processing() 
+        else: 
+            # make sure we can write to target dir 
+            testfile = self.pseudo_tempname() + '.write-test' 
+            test_exists = os.path.exists(testfile) 
+            try: 
+                if test_exists: 
+                    os.unlink(testfile) 
+                open(testfile, 'w').close() 
+                os.unlink(testfile) 
+            except (OSError, IOError): 
+                self.cant_write_to_target() 
+ 
+        if not is_site_dir and not self.multi_version: 
+            # Can't install non-multi to non-site dir 
+            raise DistutilsError(self.no_default_version_msg()) 
+ 
+        if is_site_dir: 
+            if self.pth_file is None: 
+                self.pth_file = PthDistributions(pth_file, self.all_site_dirs) 
+        else: 
+            self.pth_file = None 
+ 
         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):
-            self.sitepy_installed = True  # don't need site.py in this case
-            self.pth_file = None  # and don't create a .pth file
-        self.install_dir = instdir
-
-    __cant_write_msg = textwrap.dedent("""
-        can't create or remove files in install directory
-
-        The following error occurred while trying to add or remove files in the
-        installation directory:
-
-            %s
-
-        The installation directory you specified (via --install-dir, --prefix, or
-        the distutils default setting) was:
-
-            %s
-        """).lstrip()
-
-    __not_exists_id = textwrap.dedent("""
-        This directory does not currently exist.  Please create it and try again, or
-        choose a different installation directory (using the -d or --install-dir
-        option).
-        """).lstrip()
-
-    __access_msg = textwrap.dedent("""
-        Perhaps your account does not have write access to this directory?  If the
-        installation directory is a system-owned directory, you may need to sign in
-        as the administrator or "root" account.  If you do not have administrative
-        access to this machine, you may wish to choose a different installation
-        directory, preferably one that is listed in your PYTHONPATH environment
-        variable.
-
-        For information on other options, you may wish to consult the
-        documentation at:
-
+            # 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): 
+            self.sitepy_installed = True  # don't need site.py in this case 
+            self.pth_file = None  # and don't create a .pth file 
+        self.install_dir = instdir 
+ 
+    __cant_write_msg = textwrap.dedent(""" 
+        can't create or remove files in install directory 
+ 
+        The following error occurred while trying to add or remove files in the 
+        installation directory: 
+ 
+            %s 
+ 
+        The installation directory you specified (via --install-dir, --prefix, or 
+        the distutils default setting) was: 
+ 
+            %s 
+        """).lstrip() 
+ 
+    __not_exists_id = textwrap.dedent(""" 
+        This directory does not currently exist.  Please create it and try again, or 
+        choose a different installation directory (using the -d or --install-dir 
+        option). 
+        """).lstrip() 
+ 
+    __access_msg = textwrap.dedent(""" 
+        Perhaps your account does not have write access to this directory?  If the 
+        installation directory is a system-owned directory, you may need to sign in 
+        as the administrator or "root" account.  If you do not have administrative 
+        access to this machine, you may wish to choose a different installation 
+        directory, preferably one that is listed in your PYTHONPATH environment 
+        variable. 
+ 
+        For information on other options, you may wish to consult the 
+        documentation at: 
+ 
           https://setuptools.readthedocs.io/en/latest/easy_install.html
-
-        Please make the appropriate changes for your system and try again.
-        """).lstrip()
-
-    def cant_write_to_target(self):
-        msg = self.__cant_write_msg % (sys.exc_info()[1], self.install_dir,)
-
-        if not os.path.exists(self.install_dir):
-            msg += '\n' + self.__not_exists_id
-        else:
-            msg += '\n' + self.__access_msg
-        raise DistutilsError(msg)
-
-    def check_pth_processing(self):
-        """Empirically verify whether .pth files are supported in inst. dir"""
-        instdir = self.install_dir
-        log.info("Checking .pth file support in %s", instdir)
-        pth_file = self.pseudo_tempname() + ".pth"
-        ok_file = pth_file + '.ok'
-        ok_exists = os.path.exists(ok_file)
+ 
+        Please make the appropriate changes for your system and try again. 
+        """).lstrip() 
+ 
+    def cant_write_to_target(self): 
+        msg = self.__cant_write_msg % (sys.exc_info()[1], self.install_dir,) 
+ 
+        if not os.path.exists(self.install_dir): 
+            msg += '\n' + self.__not_exists_id 
+        else: 
+            msg += '\n' + self.__access_msg 
+        raise DistutilsError(msg) 
+ 
+    def check_pth_processing(self): 
+        """Empirically verify whether .pth files are supported in inst. dir""" 
+        instdir = self.install_dir 
+        log.info("Checking .pth file support in %s", instdir) 
+        pth_file = self.pseudo_tempname() + ".pth" 
+        ok_file = pth_file + '.ok' 
+        ok_exists = os.path.exists(ok_file) 
         tmpl = _one_liner("""
             import os
             f = open({ok_file!r}, 'w')
             f.write('OK')
             f.close()
             """) + '\n'
-        try:
-            if ok_exists:
-                os.unlink(ok_file)
-            dirname = os.path.dirname(ok_file)
+        try: 
+            if ok_exists: 
+                os.unlink(ok_file) 
+            dirname = os.path.dirname(ok_file) 
             pkg_resources.py31compat.makedirs(dirname, exist_ok=True)
-            f = open(pth_file, 'w')
-        except (OSError, IOError):
-            self.cant_write_to_target()
-        else:
-            try:
+            f = open(pth_file, 'w') 
+        except (OSError, IOError): 
+            self.cant_write_to_target() 
+        else: 
+            try: 
                 f.write(tmpl.format(**locals()))
-                f.close()
-                f = None
-                executable = sys.executable
-                if os.name == 'nt':
-                    dirname, basename = os.path.split(executable)
-                    alt = os.path.join(dirname, 'pythonw.exe')
+                f.close() 
+                f = None 
+                executable = sys.executable 
+                if os.name == 'nt': 
+                    dirname, basename = os.path.split(executable) 
+                    alt = os.path.join(dirname, 'pythonw.exe') 
                     use_alt = (
                         basename.lower() == 'python.exe' and
                         os.path.exists(alt)
                     )
                     if use_alt:
-                        # use pythonw.exe to avoid opening a console window
-                        executable = alt
-
-                from distutils.spawn import spawn
-
-                spawn([executable, '-E', '-c', 'pass'], 0)
-
-                if os.path.exists(ok_file):
-                    log.info(
-                        "TEST PASSED: %s appears to support .pth files",
-                        instdir
-                    )
-                    return True
-            finally:
-                if f:
-                    f.close()
-                if os.path.exists(ok_file):
-                    os.unlink(ok_file)
-                if os.path.exists(pth_file):
-                    os.unlink(pth_file)
-        if not self.multi_version:
-            log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
-        return False
-
-    def install_egg_scripts(self, dist):
-        """Write all the scripts for `dist`, unless scripts are excluded"""
-        if not self.exclude_scripts and dist.metadata_isdir('scripts'):
-            for script_name in dist.metadata_listdir('scripts'):
-                if dist.metadata_isdir('scripts/' + script_name):
-                    # The "script" is a directory, likely a Python 3
-                    # __pycache__ directory, so skip it.
-                    continue
-                self.install_script(
-                    dist, script_name,
-                    dist.get_metadata('scripts/' + script_name)
-                )
-        self.install_wrapper_scripts(dist)
-
-    def add_output(self, path):
-        if os.path.isdir(path):
-            for base, dirs, files in os.walk(path):
-                for filename in files:
-                    self.outputs.append(os.path.join(base, filename))
-        else:
-            self.outputs.append(path)
-
-    def not_editable(self, spec):
-        if self.editable:
-            raise DistutilsArgError(
-                "Invalid argument %r: you can't use filenames or URLs "
-                "with --editable (except via the --find-links option)."
-                % (spec,)
-            )
-
-    def check_editable(self, spec):
-        if not self.editable:
-            return
-
-        if os.path.exists(os.path.join(self.build_directory, spec.key)):
-            raise DistutilsArgError(
-                "%r already exists in %s; can't do a checkout there" %
-                (spec.key, self.build_directory)
-            )
-
+                        # use pythonw.exe to avoid opening a console window 
+                        executable = alt 
+ 
+                from distutils.spawn import spawn 
+ 
+                spawn([executable, '-E', '-c', 'pass'], 0) 
+ 
+                if os.path.exists(ok_file): 
+                    log.info( 
+                        "TEST PASSED: %s appears to support .pth files", 
+                        instdir 
+                    ) 
+                    return True 
+            finally: 
+                if f: 
+                    f.close() 
+                if os.path.exists(ok_file): 
+                    os.unlink(ok_file) 
+                if os.path.exists(pth_file): 
+                    os.unlink(pth_file) 
+        if not self.multi_version: 
+            log.warn("TEST FAILED: %s does NOT support .pth files", instdir) 
+        return False 
+ 
+    def install_egg_scripts(self, dist): 
+        """Write all the scripts for `dist`, unless scripts are excluded""" 
+        if not self.exclude_scripts and dist.metadata_isdir('scripts'): 
+            for script_name in dist.metadata_listdir('scripts'): 
+                if dist.metadata_isdir('scripts/' + script_name): 
+                    # The "script" is a directory, likely a Python 3 
+                    # __pycache__ directory, so skip it. 
+                    continue 
+                self.install_script( 
+                    dist, script_name, 
+                    dist.get_metadata('scripts/' + script_name) 
+                ) 
+        self.install_wrapper_scripts(dist) 
+ 
+    def add_output(self, path): 
+        if os.path.isdir(path): 
+            for base, dirs, files in os.walk(path): 
+                for filename in files: 
+                    self.outputs.append(os.path.join(base, filename)) 
+        else: 
+            self.outputs.append(path) 
+ 
+    def not_editable(self, spec): 
+        if self.editable: 
+            raise DistutilsArgError( 
+                "Invalid argument %r: you can't use filenames or URLs " 
+                "with --editable (except via the --find-links option)." 
+                % (spec,) 
+            ) 
+ 
+    def check_editable(self, spec): 
+        if not self.editable: 
+            return 
+ 
+        if os.path.exists(os.path.join(self.build_directory, spec.key)): 
+            raise DistutilsArgError( 
+                "%r already exists in %s; can't do a checkout there" % 
+                (spec.key, self.build_directory) 
+            ) 
+ 
     @contextlib.contextmanager
     def _tmpdir(self):
         tmpdir = tempfile.mkdtemp(prefix=u"easy_install-")
@@ -648,296 +648,296 @@ class easy_install(Command):
         finally:
             os.path.exists(tmpdir) and rmtree(rmtree_safe(tmpdir))
 
-    def easy_install(self, spec, deps=False):
-        if not self.editable:
-            self.install_site_py()
-
+    def easy_install(self, spec, deps=False): 
+        if not self.editable: 
+            self.install_site_py() 
+ 
         with self._tmpdir() as tmpdir:
-            if not isinstance(spec, Requirement):
-                if URL_SCHEME(spec):
-                    # It's a url, download it to tmpdir and process
-                    self.not_editable(spec)
+            if not isinstance(spec, Requirement): 
+                if URL_SCHEME(spec): 
+                    # It's a url, download it to tmpdir and process 
+                    self.not_editable(spec) 
                     dl = self.package_index.download(spec, tmpdir)
                     return self.install_item(None, dl, tmpdir, deps, True)
-
-                elif os.path.exists(spec):
-                    # Existing file or directory, just process it directly
-                    self.not_editable(spec)
-                    return self.install_item(None, spec, tmpdir, deps, True)
-                else:
-                    spec = parse_requirement_arg(spec)
-
-            self.check_editable(spec)
-            dist = self.package_index.fetch_distribution(
-                spec, tmpdir, self.upgrade, self.editable,
-                not self.always_copy, self.local_index
-            )
-            if dist is None:
-                msg = "Could not find suitable distribution for %r" % spec
-                if self.always_copy:
-                    msg += " (--always-copy skips system and development eggs)"
-                raise DistutilsError(msg)
-            elif dist.precedence == DEVELOP_DIST:
-                # .egg-info dists don't need installing, just process deps
-                self.process_distribution(spec, dist, deps, "Using")
-                return dist
-            else:
-                return self.install_item(spec, dist.location, tmpdir, deps)
-
-    def install_item(self, spec, download, tmpdir, deps, install_needed=False):
-
-        # Installation is also needed if file in tmpdir or is not an egg
-        install_needed = install_needed or self.always_copy
-        install_needed = install_needed or os.path.dirname(download) == tmpdir
-        install_needed = install_needed or not download.endswith('.egg')
-        install_needed = install_needed or (
-            self.always_copy_from is not None and
-            os.path.dirname(normalize_path(download)) ==
-            normalize_path(self.always_copy_from)
-        )
-
-        if spec and not install_needed:
-            # at this point, we know it's a local .egg, we just don't know if
-            # it's already installed.
-            for dist in self.local_index[spec.project_name]:
-                if dist.location == download:
-                    break
-            else:
-                install_needed = True  # it's not in the local index
-
-        log.info("Processing %s", os.path.basename(download))
-
-        if install_needed:
-            dists = self.install_eggs(spec, download, tmpdir)
-            for dist in dists:
-                self.process_distribution(spec, dist, deps)
-        else:
-            dists = [self.egg_distribution(download)]
-            self.process_distribution(spec, dists[0], deps, "Using")
-
-        if spec is not None:
-            for dist in dists:
-                if dist in spec:
-                    return dist
-
-    def select_scheme(self, name):
-        """Sets the install directories by applying the install schemes."""
-        # it's the caller's problem if they supply a bad name!
-        scheme = INSTALL_SCHEMES[name]
-        for key in SCHEME_KEYS:
-            attrname = 'install_' + key
-            if getattr(self, attrname) is None:
-                setattr(self, attrname, scheme[key])
-
-    def process_distribution(self, requirement, dist, deps=True, *info):
-        self.update_pth(dist)
-        self.package_index.add(dist)
-        if dist in self.local_index[dist.key]:
-            self.local_index.remove(dist)
-        self.local_index.add(dist)
-        self.install_egg_scripts(dist)
-        self.installed_projects[dist.key] = dist
-        log.info(self.installation_report(requirement, dist, *info))
-        if (dist.has_metadata('dependency_links.txt') and
-                not self.no_find_links):
-            self.package_index.add_find_links(
-                dist.get_metadata_lines('dependency_links.txt')
-            )
-        if not deps and not self.always_copy:
-            return
-        elif requirement is not None and dist.key != requirement.key:
-            log.warn("Skipping dependencies for %s", dist)
-            return  # XXX this is not the distribution we were looking for
-        elif requirement is None or dist not in requirement:
-            # if we wound up with a different version, resolve what we've got
-            distreq = dist.as_requirement()
+ 
+                elif os.path.exists(spec): 
+                    # Existing file or directory, just process it directly 
+                    self.not_editable(spec) 
+                    return self.install_item(None, spec, tmpdir, deps, True) 
+                else: 
+                    spec = parse_requirement_arg(spec) 
+ 
+            self.check_editable(spec) 
+            dist = self.package_index.fetch_distribution( 
+                spec, tmpdir, self.upgrade, self.editable, 
+                not self.always_copy, self.local_index 
+            ) 
+            if dist is None: 
+                msg = "Could not find suitable distribution for %r" % spec 
+                if self.always_copy: 
+                    msg += " (--always-copy skips system and development eggs)" 
+                raise DistutilsError(msg) 
+            elif dist.precedence == DEVELOP_DIST: 
+                # .egg-info dists don't need installing, just process deps 
+                self.process_distribution(spec, dist, deps, "Using") 
+                return dist 
+            else: 
+                return self.install_item(spec, dist.location, tmpdir, deps) 
+ 
+    def install_item(self, spec, download, tmpdir, deps, install_needed=False): 
+ 
+        # Installation is also needed if file in tmpdir or is not an egg 
+        install_needed = install_needed or self.always_copy 
+        install_needed = install_needed or os.path.dirname(download) == tmpdir 
+        install_needed = install_needed or not download.endswith('.egg') 
+        install_needed = install_needed or ( 
+            self.always_copy_from is not None and 
+            os.path.dirname(normalize_path(download)) == 
+            normalize_path(self.always_copy_from) 
+        ) 
+ 
+        if spec and not install_needed: 
+            # at this point, we know it's a local .egg, we just don't know if 
+            # it's already installed. 
+            for dist in self.local_index[spec.project_name]: 
+                if dist.location == download: 
+                    break 
+            else: 
+                install_needed = True  # it's not in the local index 
+ 
+        log.info("Processing %s", os.path.basename(download)) 
+ 
+        if install_needed: 
+            dists = self.install_eggs(spec, download, tmpdir) 
+            for dist in dists: 
+                self.process_distribution(spec, dist, deps) 
+        else: 
+            dists = [self.egg_distribution(download)] 
+            self.process_distribution(spec, dists[0], deps, "Using") 
+ 
+        if spec is not None: 
+            for dist in dists: 
+                if dist in spec: 
+                    return dist 
+ 
+    def select_scheme(self, name): 
+        """Sets the install directories by applying the install schemes.""" 
+        # it's the caller's problem if they supply a bad name! 
+        scheme = INSTALL_SCHEMES[name] 
+        for key in SCHEME_KEYS: 
+            attrname = 'install_' + key 
+            if getattr(self, attrname) is None: 
+                setattr(self, attrname, scheme[key]) 
+ 
+    def process_distribution(self, requirement, dist, deps=True, *info): 
+        self.update_pth(dist) 
+        self.package_index.add(dist) 
+        if dist in self.local_index[dist.key]: 
+            self.local_index.remove(dist) 
+        self.local_index.add(dist) 
+        self.install_egg_scripts(dist) 
+        self.installed_projects[dist.key] = dist 
+        log.info(self.installation_report(requirement, dist, *info)) 
+        if (dist.has_metadata('dependency_links.txt') and 
+                not self.no_find_links): 
+            self.package_index.add_find_links( 
+                dist.get_metadata_lines('dependency_links.txt') 
+            ) 
+        if not deps and not self.always_copy: 
+            return 
+        elif requirement is not None and dist.key != requirement.key: 
+            log.warn("Skipping dependencies for %s", dist) 
+            return  # XXX this is not the distribution we were looking for 
+        elif requirement is None or dist not in requirement: 
+            # if we wound up with a different version, resolve what we've got 
+            distreq = dist.as_requirement() 
             requirement = Requirement(str(distreq))
-        log.info("Processing dependencies for %s", requirement)
-        try:
-            distros = WorkingSet([]).resolve(
-                [requirement], self.local_index, self.easy_install
-            )
-        except DistributionNotFound as e:
-            raise DistutilsError(str(e))
-        except VersionConflict as e:
-            raise DistutilsError(e.report())
-        if self.always_copy or self.always_copy_from:
-            # Force all the relevant distros to be copied or activated
-            for dist in distros:
-                if dist.key not in self.installed_projects:
-                    self.easy_install(dist.as_requirement())
-        log.info("Finished processing dependencies for %s", requirement)
-
-    def should_unzip(self, dist):
-        if self.zip_ok is not None:
-            return not self.zip_ok
-        if dist.has_metadata('not-zip-safe'):
-            return True
-        if not dist.has_metadata('zip-safe'):
-            return True
-        return False
-
-    def maybe_move(self, spec, dist_filename, setup_base):
-        dst = os.path.join(self.build_directory, spec.key)
-        if os.path.exists(dst):
+        log.info("Processing dependencies for %s", requirement) 
+        try: 
+            distros = WorkingSet([]).resolve( 
+                [requirement], self.local_index, self.easy_install 
+            ) 
+        except DistributionNotFound as e: 
+            raise DistutilsError(str(e)) 
+        except VersionConflict as e: 
+            raise DistutilsError(e.report()) 
+        if self.always_copy or self.always_copy_from: 
+            # Force all the relevant distros to be copied or activated 
+            for dist in distros: 
+                if dist.key not in self.installed_projects: 
+                    self.easy_install(dist.as_requirement()) 
+        log.info("Finished processing dependencies for %s", requirement) 
+ 
+    def should_unzip(self, dist): 
+        if self.zip_ok is not None: 
+            return not self.zip_ok 
+        if dist.has_metadata('not-zip-safe'): 
+            return True 
+        if not dist.has_metadata('zip-safe'): 
+            return True 
+        return False 
+ 
+    def maybe_move(self, spec, dist_filename, setup_base): 
+        dst = os.path.join(self.build_directory, spec.key) 
+        if os.path.exists(dst): 
             msg = (
                 "%r already exists in %s; build directory %s will not be kept"
             )
-            log.warn(msg, spec.key, self.build_directory, setup_base)
-            return setup_base
-        if os.path.isdir(dist_filename):
-            setup_base = dist_filename
-        else:
-            if os.path.dirname(dist_filename) == setup_base:
-                os.unlink(dist_filename)  # get it out of the tmp dir
-            contents = os.listdir(setup_base)
-            if len(contents) == 1:
-                dist_filename = os.path.join(setup_base, contents[0])
-                if os.path.isdir(dist_filename):
-                    # if the only thing there is a directory, move it instead
-                    setup_base = dist_filename
-        ensure_directory(dst)
-        shutil.move(setup_base, dst)
-        return dst
-
-    def install_wrapper_scripts(self, dist):
-        if self.exclude_scripts:
-            return
-        for args in ScriptWriter.best().get_args(dist):
-            self.write_script(*args)
-
-    def install_script(self, dist, script_name, script_text, dev_path=None):
-        """Generate a legacy script wrapper and install it"""
-        spec = str(dist.as_requirement())
-        is_script = is_python_script(script_text, script_name)
-
-        if is_script:
-            body = self._load_template(dev_path) % locals()
-            script_text = ScriptWriter.get_header(script_text) + body
+            log.warn(msg, spec.key, self.build_directory, setup_base) 
+            return setup_base 
+        if os.path.isdir(dist_filename): 
+            setup_base = dist_filename 
+        else: 
+            if os.path.dirname(dist_filename) == setup_base: 
+                os.unlink(dist_filename)  # get it out of the tmp dir 
+            contents = os.listdir(setup_base) 
+            if len(contents) == 1: 
+                dist_filename = os.path.join(setup_base, contents[0]) 
+                if os.path.isdir(dist_filename): 
+                    # if the only thing there is a directory, move it instead 
+                    setup_base = dist_filename 
+        ensure_directory(dst) 
+        shutil.move(setup_base, dst) 
+        return dst 
+ 
+    def install_wrapper_scripts(self, dist): 
+        if self.exclude_scripts: 
+            return 
+        for args in ScriptWriter.best().get_args(dist): 
+            self.write_script(*args) 
+ 
+    def install_script(self, dist, script_name, script_text, dev_path=None): 
+        """Generate a legacy script wrapper and install it""" 
+        spec = str(dist.as_requirement()) 
+        is_script = is_python_script(script_text, script_name) 
+ 
+        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')
-
-    @staticmethod
-    def _load_template(dev_path):
-        """
-        There are a couple of template scripts in the package. This
-        function loads one of them and prepares it for use.
-        """
+ 
+    @staticmethod 
+    def _load_template(dev_path): 
+        """ 
+        There are a couple of template scripts in the package. This 
+        function loads one of them and prepares it for use. 
+        """ 
         # See https://github.com/pypa/setuptools/issues/134 for info
-        # on script file naming and downstream issues with SVR4
-        name = 'script.tmpl'
-        if dev_path:
-            name = name.replace('.tmpl', ' (dev).tmpl')
-
-        raw_bytes = resource_string('setuptools', name)
-        return raw_bytes.decode('utf-8')
-
-    def write_script(self, script_name, contents, mode="t", blockers=()):
-        """Write an executable file to the scripts directory"""
-        self.delete_blockers(  # clean up old .py/.pyw w/o a script
-            [os.path.join(self.script_dir, x) for x in blockers]
-        )
-        log.info("Installing %s script to %s", script_name, self.script_dir)
-        target = os.path.join(self.script_dir, script_name)
-        self.add_output(target)
-
+        # on script file naming and downstream issues with SVR4 
+        name = 'script.tmpl' 
+        if dev_path: 
+            name = name.replace('.tmpl', ' (dev).tmpl') 
+ 
+        raw_bytes = resource_string('setuptools', name) 
+        return raw_bytes.decode('utf-8') 
+ 
+    def write_script(self, script_name, contents, mode="t", blockers=()): 
+        """Write an executable file to the scripts directory""" 
+        self.delete_blockers(  # clean up old .py/.pyw w/o a script 
+            [os.path.join(self.script_dir, x) for x in blockers] 
+        ) 
+        log.info("Installing %s script to %s", script_name, self.script_dir) 
+        target = os.path.join(self.script_dir, script_name) 
+        self.add_output(target) 
+ 
         if self.dry_run:
             return
 
-        mask = current_umask()
+        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)
-
-    def install_eggs(self, spec, dist_filename, tmpdir):
-        # .egg dirs or files are already built, so just return them
-        if dist_filename.lower().endswith('.egg'):
-            return [self.install_egg(dist_filename, tmpdir)]
-        elif dist_filename.lower().endswith('.exe'):
-            return [self.install_exe(dist_filename, tmpdir)]
+ 
+    def install_eggs(self, spec, dist_filename, tmpdir): 
+        # .egg dirs or files are already built, so just return them 
+        if dist_filename.lower().endswith('.egg'): 
+            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)]
-
-        # Anything else, try to extract and build
-        setup_base = tmpdir
-        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
-            unpack_archive(dist_filename, tmpdir, self.unpack_progress)
-        elif os.path.isdir(dist_filename):
-            setup_base = os.path.abspath(dist_filename)
-
-        if (setup_base.startswith(tmpdir)  # something we downloaded
-                and self.build_directory and spec is not None):
-            setup_base = self.maybe_move(spec, dist_filename, setup_base)
-
-        # Find the setup.py file
-        setup_script = os.path.join(setup_base, 'setup.py')
-
-        if not os.path.exists(setup_script):
-            setups = glob(os.path.join(setup_base, '*', 'setup.py'))
-            if not setups:
-                raise DistutilsError(
-                    "Couldn't find a setup script in %s" %
-                    os.path.abspath(dist_filename)
-                )
-            if len(setups) > 1:
-                raise DistutilsError(
-                    "Multiple setup scripts in %s" %
-                    os.path.abspath(dist_filename)
-                )
-            setup_script = setups[0]
-
-        # Now run it, and return the result
-        if self.editable:
-            log.info(self.report_editable(spec, setup_script))
-            return []
-        else:
-            return self.build_and_install(setup_script, setup_base)
-
-    def egg_distribution(self, egg_path):
-        if os.path.isdir(egg_path):
-            metadata = PathMetadata(egg_path, os.path.join(egg_path,
-                                                           'EGG-INFO'))
-        else:
-            metadata = EggMetadata(zipimport.zipimporter(egg_path))
-        return Distribution.from_filename(egg_path, metadata=metadata)
-
-    def install_egg(self, egg_path, tmpdir):
+ 
+        # Anything else, try to extract and build 
+        setup_base = tmpdir 
+        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'): 
+            unpack_archive(dist_filename, tmpdir, self.unpack_progress) 
+        elif os.path.isdir(dist_filename): 
+            setup_base = os.path.abspath(dist_filename) 
+ 
+        if (setup_base.startswith(tmpdir)  # something we downloaded 
+                and self.build_directory and spec is not None): 
+            setup_base = self.maybe_move(spec, dist_filename, setup_base) 
+ 
+        # Find the setup.py file 
+        setup_script = os.path.join(setup_base, 'setup.py') 
+ 
+        if not os.path.exists(setup_script): 
+            setups = glob(os.path.join(setup_base, '*', 'setup.py')) 
+            if not setups: 
+                raise DistutilsError( 
+                    "Couldn't find a setup script in %s" % 
+                    os.path.abspath(dist_filename) 
+                ) 
+            if len(setups) > 1: 
+                raise DistutilsError( 
+                    "Multiple setup scripts in %s" % 
+                    os.path.abspath(dist_filename) 
+                ) 
+            setup_script = setups[0] 
+ 
+        # Now run it, and return the result 
+        if self.editable: 
+            log.info(self.report_editable(spec, setup_script)) 
+            return [] 
+        else: 
+            return self.build_and_install(setup_script, setup_base) 
+ 
+    def egg_distribution(self, egg_path): 
+        if os.path.isdir(egg_path): 
+            metadata = PathMetadata(egg_path, os.path.join(egg_path, 
+                                                           'EGG-INFO')) 
+        else: 
+            metadata = EggMetadata(zipimport.zipimporter(egg_path)) 
+        return Distribution.from_filename(egg_path, metadata=metadata) 
+ 
+    def install_egg(self, egg_path, tmpdir): 
         destination = os.path.join(
             self.install_dir,
             os.path.basename(egg_path),
         )
-        destination = os.path.abspath(destination)
-        if not self.dry_run:
-            ensure_directory(destination)
-
-        dist = self.egg_distribution(egg_path)
-        if not samefile(egg_path, 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):
+        destination = os.path.abspath(destination) 
+        if not self.dry_run: 
+            ensure_directory(destination) 
+ 
+        dist = self.egg_distribution(egg_path) 
+        if not samefile(egg_path, 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:
-                new_dist_is_zipped = False
-                if os.path.isdir(egg_path):
-                    if egg_path.startswith(tmpdir):
-                        f, m = shutil.move, "Moving"
-                    else:
-                        f, m = shutil.copytree, "Copying"
-                elif self.should_unzip(dist):
-                    self.mkpath(destination)
-                    f, m = self.unpack_and_compile, "Extracting"
-                else:
-                    new_dist_is_zipped = True
-                    if egg_path.startswith(tmpdir):
-                        f, m = shutil.move, "Moving"
-                    else:
-                        f, m = shutil.copy2, "Copying"
+            try: 
+                new_dist_is_zipped = False 
+                if os.path.isdir(egg_path): 
+                    if egg_path.startswith(tmpdir): 
+                        f, m = shutil.move, "Moving" 
+                    else: 
+                        f, m = shutil.copytree, "Copying" 
+                elif self.should_unzip(dist): 
+                    self.mkpath(destination) 
+                    f, m = self.unpack_and_compile, "Extracting" 
+                else: 
+                    new_dist_is_zipped = True 
+                    if egg_path.startswith(tmpdir): 
+                        f, m = shutil.move, "Moving" 
+                    else: 
+                        f, m = shutil.copy2, "Copying" 
                 self.execute(
                     f,
                     (egg_path, destination),
@@ -951,110 +951,110 @@ class easy_install(Command):
                     fix_zipimporter_caches=new_dist_is_zipped,
                 )
             except Exception:
-                update_dist_caches(destination, fix_zipimporter_caches=False)
-                raise
-
-        self.add_output(destination)
-        return self.egg_distribution(destination)
-
-    def install_exe(self, dist_filename, tmpdir):
-        # See if it's valid, get data
-        cfg = extract_wininst_cfg(dist_filename)
-        if cfg is None:
-            raise DistutilsError(
-                "%s is not a valid distutils Windows .exe" % dist_filename
-            )
-        # Create a dummy distribution object until we build the real distro
-        dist = Distribution(
-            None,
-            project_name=cfg.get('metadata', 'name'),
-            version=cfg.get('metadata', 'version'), platform=get_platform(),
-        )
-
-        # Convert the .exe to an unpacked egg
+                update_dist_caches(destination, fix_zipimporter_caches=False) 
+                raise 
+ 
+        self.add_output(destination) 
+        return self.egg_distribution(destination) 
+ 
+    def install_exe(self, dist_filename, tmpdir): 
+        # See if it's valid, get data 
+        cfg = extract_wininst_cfg(dist_filename) 
+        if cfg is None: 
+            raise DistutilsError( 
+                "%s is not a valid distutils Windows .exe" % dist_filename 
+            ) 
+        # Create a dummy distribution object until we build the real distro 
+        dist = Distribution( 
+            None, 
+            project_name=cfg.get('metadata', 'name'), 
+            version=cfg.get('metadata', 'version'), platform=get_platform(), 
+        ) 
+ 
+        # Convert the .exe to an unpacked egg 
         egg_path = os.path.join(tmpdir, dist.egg_name() + '.egg')
         dist.location = egg_path
-        egg_tmp = egg_path + '.tmp'
-        _egg_info = os.path.join(egg_tmp, 'EGG-INFO')
-        pkg_inf = os.path.join(_egg_info, 'PKG-INFO')
-        ensure_directory(pkg_inf)  # make sure EGG-INFO dir exists
-        dist._provider = PathMetadata(egg_tmp, _egg_info)  # XXX
-        self.exe_to_egg(dist_filename, egg_tmp)
-
-        # Write EGG-INFO/PKG-INFO
-        if not os.path.exists(pkg_inf):
-            f = open(pkg_inf, 'w')
-            f.write('Metadata-Version: 1.0\n')
-            for k, v in cfg.items('metadata'):
-                if k != 'target_version':
-                    f.write('%s: %s\n' % (k.replace('_', '-').title(), v))
-            f.close()
-        script_dir = os.path.join(_egg_info, 'scripts')
-        # delete entry-point scripts to avoid duping
+        egg_tmp = egg_path + '.tmp' 
+        _egg_info = os.path.join(egg_tmp, 'EGG-INFO') 
+        pkg_inf = os.path.join(_egg_info, 'PKG-INFO') 
+        ensure_directory(pkg_inf)  # make sure EGG-INFO dir exists 
+        dist._provider = PathMetadata(egg_tmp, _egg_info)  # XXX 
+        self.exe_to_egg(dist_filename, egg_tmp) 
+ 
+        # Write EGG-INFO/PKG-INFO 
+        if not os.path.exists(pkg_inf): 
+            f = open(pkg_inf, 'w') 
+            f.write('Metadata-Version: 1.0\n') 
+            for k, v in cfg.items('metadata'): 
+                if k != 'target_version': 
+                    f.write('%s: %s\n' % (k.replace('_', '-').title(), v)) 
+            f.close() 
+        script_dir = os.path.join(_egg_info, 'scripts') 
+        # delete entry-point scripts to avoid duping 
         self.delete_blockers([
             os.path.join(script_dir, args[0])
             for args in ScriptWriter.get_args(dist)
         ])
-        # Build .egg file from tmpdir
-        bdist_egg.make_zipfile(
+        # Build .egg file from tmpdir 
+        bdist_egg.make_zipfile( 
             egg_path, egg_tmp, verbose=self.verbose, dry_run=self.dry_run,
-        )
-        # install the .egg
-        return self.install_egg(egg_path, tmpdir)
-
-    def exe_to_egg(self, dist_filename, egg_tmp):
-        """Extract a bdist_wininst to the directories an egg would use"""
-        # Check for .pth file and set up prefix translations
-        prefixes = get_exe_prefixes(dist_filename)
-        to_compile = []
-        native_libs = []
-        top_level = {}
-
-        def process(src, dst):
-            s = src.lower()
-            for old, new in prefixes:
-                if s.startswith(old):
-                    src = new + src[len(old):]
-                    parts = src.split('/')
-                    dst = os.path.join(egg_tmp, *parts)
-                    dl = dst.lower()
-                    if dl.endswith('.pyd') or dl.endswith('.dll'):
-                        parts[-1] = bdist_egg.strip_module(parts[-1])
-                        top_level[os.path.splitext(parts[0])[0]] = 1
-                        native_libs.append(src)
-                    elif dl.endswith('.py') and old != 'SCRIPTS/':
-                        top_level[os.path.splitext(parts[0])[0]] = 1
-                        to_compile.append(dst)
-                    return dst
-            if not src.endswith('.pth'):
-                log.warn("WARNING: can't process %s", src)
-            return None
-
-        # extract, tracking .pyd/.dll->native_libs and .py -> to_compile
-        unpack_archive(dist_filename, egg_tmp, process)
-        stubs = []
-        for res in native_libs:
-            if res.lower().endswith('.pyd'):  # create stubs for .pyd's
-                parts = res.split('/')
-                resource = parts[-1]
-                parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py'
-                pyfile = os.path.join(egg_tmp, *parts)
-                to_compile.append(pyfile)
-                stubs.append(pyfile)
-                bdist_egg.write_stub(resource, pyfile)
-        self.byte_compile(to_compile)  # compile .py's
-        bdist_egg.write_safety_flag(
-            os.path.join(egg_tmp, 'EGG-INFO'),
-            bdist_egg.analyze_egg(egg_tmp, stubs))  # write zip-safety flag
-
-        for name in 'top_level', 'native_libs':
-            if locals()[name]:
-                txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt')
-                if not os.path.exists(txt):
-                    f = open(txt, 'w')
-                    f.write('\n'.join(locals()[name]) + '\n')
-                    f.close()
-
+        ) 
+        # install the .egg 
+        return self.install_egg(egg_path, tmpdir) 
+ 
+    def exe_to_egg(self, dist_filename, egg_tmp): 
+        """Extract a bdist_wininst to the directories an egg would use""" 
+        # Check for .pth file and set up prefix translations 
+        prefixes = get_exe_prefixes(dist_filename) 
+        to_compile = [] 
+        native_libs = [] 
+        top_level = {} 
+ 
+        def process(src, dst): 
+            s = src.lower() 
+            for old, new in prefixes: 
+                if s.startswith(old): 
+                    src = new + src[len(old):] 
+                    parts = src.split('/') 
+                    dst = os.path.join(egg_tmp, *parts) 
+                    dl = dst.lower() 
+                    if dl.endswith('.pyd') or dl.endswith('.dll'): 
+                        parts[-1] = bdist_egg.strip_module(parts[-1]) 
+                        top_level[os.path.splitext(parts[0])[0]] = 1 
+                        native_libs.append(src) 
+                    elif dl.endswith('.py') and old != 'SCRIPTS/': 
+                        top_level[os.path.splitext(parts[0])[0]] = 1 
+                        to_compile.append(dst) 
+                    return dst 
+            if not src.endswith('.pth'): 
+                log.warn("WARNING: can't process %s", src) 
+            return None 
+ 
+        # extract, tracking .pyd/.dll->native_libs and .py -> to_compile 
+        unpack_archive(dist_filename, egg_tmp, process) 
+        stubs = [] 
+        for res in native_libs: 
+            if res.lower().endswith('.pyd'):  # create stubs for .pyd's 
+                parts = res.split('/') 
+                resource = parts[-1] 
+                parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py' 
+                pyfile = os.path.join(egg_tmp, *parts) 
+                to_compile.append(pyfile) 
+                stubs.append(pyfile) 
+                bdist_egg.write_stub(resource, pyfile) 
+        self.byte_compile(to_compile)  # compile .py's 
+        bdist_egg.write_safety_flag( 
+            os.path.join(egg_tmp, 'EGG-INFO'), 
+            bdist_egg.analyze_egg(egg_tmp, stubs))  # write zip-safety flag 
+ 
+        for name in 'top_level', 'native_libs': 
+            if locals()[name]: 
+                txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt') 
+                if not os.path.exists(txt): 
+                    f = open(txt, 'w') 
+                    f.write('\n'.join(locals()[name]) + '\n') 
+                    f.close() 
+ 
     def install_wheel(self, wheel_path, tmpdir):
         wheel = Wheel(wheel_path)
         assert wheel.is_compatible()
@@ -1084,318 +1084,318 @@ class easy_install(Command):
         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
-        'import pkg_resources' and then use a 'require()' call similar to one of
-        these examples, in order to select the desired version:
-
-            pkg_resources.require("%(name)s")  # latest installed version
-            pkg_resources.require("%(name)s==%(version)s")  # this exact version
-            pkg_resources.require("%(name)s>=%(version)s")  # this version or higher
-        """).lstrip()
-
-    __id_warning = textwrap.dedent("""
-        Note also that the installation directory must be on sys.path at runtime for
-        this to work.  (e.g. by being the application's script directory, by being on
-        PYTHONPATH, or by being added to sys.path by your code.)
-        """)
-
-    def installation_report(self, req, dist, what="Installed"):
-        """Helpful installation message for display to package users"""
-        msg = "\n%(what)s %(eggloc)s%(extras)s"
-        if self.multi_version and not self.no_report:
-            msg += '\n' + self.__mv_warning
-            if self.install_dir not in map(normalize_path, sys.path):
-                msg += '\n' + self.__id_warning
-
-        eggloc = dist.location
-        name = dist.project_name
-        version = dist.version
-        extras = ''  # TODO: self.report_extras(req, dist)
-        return msg % locals()
-
-    __editable_msg = textwrap.dedent("""
-        Extracted editable version of %(spec)s to %(dirname)s
-
-        If it uses setuptools in its setup script, you can activate it in
-        "development" mode by going to that directory and running::
-
-            %(python)s setup.py develop
-
-        See the setuptools documentation for the "develop" command for more info.
-        """).lstrip()
-
-    def report_editable(self, spec, setup_script):
-        dirname = os.path.dirname(setup_script)
-        python = sys.executable
-        return '\n' + self.__editable_msg % locals()
-
-    def run_setup(self, setup_script, setup_base, args):
-        sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
-        sys.modules.setdefault('distutils.command.egg_info', egg_info)
-
-        args = list(args)
-        if self.verbose > 2:
-            v = 'v' * (self.verbose - 1)
-            args.insert(0, '-' + v)
-        elif self.verbose < 2:
-            args.insert(0, '-q')
-        if self.dry_run:
-            args.insert(0, '-n')
-        log.info(
-            "Running %s %s", setup_script[len(setup_base) + 1:], ' '.join(args)
-        )
-        try:
-            run_setup(setup_script, args)
-        except SystemExit as v:
-            raise DistutilsError("Setup script exited with %s" % (v.args[0],))
-
-    def build_and_install(self, setup_script, setup_base):
-        args = ['bdist_egg', '--dist-dir']
-
-        dist_dir = tempfile.mkdtemp(
-            prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
-        )
-        try:
-            self._set_fetcher_options(os.path.dirname(setup_script))
-            args.append(dist_dir)
-
-            self.run_setup(setup_script, setup_base, args)
-            all_eggs = Environment([dist_dir])
-            eggs = []
-            for key in all_eggs:
-                for dist in all_eggs[key]:
-                    eggs.append(self.install_egg(dist.location, setup_base))
-            if not eggs and not self.dry_run:
-                log.warn("No eggs found in %s (setup script problem?)",
-                         dist_dir)
-            return eggs
-        finally:
-            rmtree(dist_dir)
-            log.set_verbosity(self.verbose)  # restore our log verbosity
-
-    def _set_fetcher_options(self, base):
-        """
-        When easy_install is about to run bdist_egg on a source dist, that
-        source dist might have 'setup_requires' directives, requiring
-        additional fetching. Ensure the fetcher options given to easy_install
-        are available to that command as well.
-        """
-        # find the fetch options from easy_install and write them out
-        # to the setup.cfg file.
-        ei_opts = self.distribution.get_option_dict('easy_install').copy()
-        fetch_directives = (
+    __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 
+        'import pkg_resources' and then use a 'require()' call similar to one of 
+        these examples, in order to select the desired version: 
+ 
+            pkg_resources.require("%(name)s")  # latest installed version 
+            pkg_resources.require("%(name)s==%(version)s")  # this exact version 
+            pkg_resources.require("%(name)s>=%(version)s")  # this version or higher 
+        """).lstrip() 
+ 
+    __id_warning = textwrap.dedent(""" 
+        Note also that the installation directory must be on sys.path at runtime for 
+        this to work.  (e.g. by being the application's script directory, by being on 
+        PYTHONPATH, or by being added to sys.path by your code.) 
+        """) 
+ 
+    def installation_report(self, req, dist, what="Installed"): 
+        """Helpful installation message for display to package users""" 
+        msg = "\n%(what)s %(eggloc)s%(extras)s" 
+        if self.multi_version and not self.no_report: 
+            msg += '\n' + self.__mv_warning 
+            if self.install_dir not in map(normalize_path, sys.path): 
+                msg += '\n' + self.__id_warning 
+ 
+        eggloc = dist.location 
+        name = dist.project_name 
+        version = dist.version 
+        extras = ''  # TODO: self.report_extras(req, dist) 
+        return msg % locals() 
+ 
+    __editable_msg = textwrap.dedent(""" 
+        Extracted editable version of %(spec)s to %(dirname)s 
+ 
+        If it uses setuptools in its setup script, you can activate it in 
+        "development" mode by going to that directory and running:: 
+ 
+            %(python)s setup.py develop 
+ 
+        See the setuptools documentation for the "develop" command for more info. 
+        """).lstrip() 
+ 
+    def report_editable(self, spec, setup_script): 
+        dirname = os.path.dirname(setup_script) 
+        python = sys.executable 
+        return '\n' + self.__editable_msg % locals() 
+ 
+    def run_setup(self, setup_script, setup_base, args): 
+        sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg) 
+        sys.modules.setdefault('distutils.command.egg_info', egg_info) 
+ 
+        args = list(args) 
+        if self.verbose > 2: 
+            v = 'v' * (self.verbose - 1) 
+            args.insert(0, '-' + v) 
+        elif self.verbose < 2: 
+            args.insert(0, '-q') 
+        if self.dry_run: 
+            args.insert(0, '-n') 
+        log.info( 
+            "Running %s %s", setup_script[len(setup_base) + 1:], ' '.join(args) 
+        ) 
+        try: 
+            run_setup(setup_script, args) 
+        except SystemExit as v: 
+            raise DistutilsError("Setup script exited with %s" % (v.args[0],)) 
+ 
+    def build_and_install(self, setup_script, setup_base): 
+        args = ['bdist_egg', '--dist-dir'] 
+ 
+        dist_dir = tempfile.mkdtemp( 
+            prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script) 
+        ) 
+        try: 
+            self._set_fetcher_options(os.path.dirname(setup_script)) 
+            args.append(dist_dir) 
+ 
+            self.run_setup(setup_script, setup_base, args) 
+            all_eggs = Environment([dist_dir]) 
+            eggs = [] 
+            for key in all_eggs: 
+                for dist in all_eggs[key]: 
+                    eggs.append(self.install_egg(dist.location, setup_base)) 
+            if not eggs and not self.dry_run: 
+                log.warn("No eggs found in %s (setup script problem?)", 
+                         dist_dir) 
+            return eggs 
+        finally: 
+            rmtree(dist_dir) 
+            log.set_verbosity(self.verbose)  # restore our log verbosity 
+ 
+    def _set_fetcher_options(self, base): 
+        """ 
+        When easy_install is about to run bdist_egg on a source dist, that 
+        source dist might have 'setup_requires' directives, requiring 
+        additional fetching. Ensure the fetcher options given to easy_install 
+        are available to that command as well. 
+        """ 
+        # find the fetch options from easy_install and write them out 
+        # 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',
-        )
-        fetch_options = {}
-        for key, val in ei_opts.items():
-            if key not in fetch_directives:
-                continue
-            fetch_options[key.replace('_', '-')] = val[1]
-        # create a settings dictionary suitable for `edit_config`
-        settings = dict(easy_install=fetch_options)
-        cfg_filename = os.path.join(base, 'setup.cfg')
-        setopt.edit_config(cfg_filename, settings)
-
-    def update_pth(self, dist):
-        if self.pth_file is None:
-            return
-
-        for d in self.pth_file[dist.key]:  # drop old entries
-            if self.multi_version or d.location != dist.location:
-                log.info("Removing %s from easy-install.pth file", d)
-                self.pth_file.remove(d)
-                if d.location in self.shadow_path:
-                    self.shadow_path.remove(d.location)
-
-        if not self.multi_version:
-            if dist.location in self.pth_file.paths:
-                log.info(
-                    "%s is already the active version in easy-install.pth",
+        ) 
+        fetch_options = {} 
+        for key, val in ei_opts.items(): 
+            if key not in fetch_directives: 
+                continue 
+            fetch_options[key.replace('_', '-')] = val[1] 
+        # create a settings dictionary suitable for `edit_config` 
+        settings = dict(easy_install=fetch_options) 
+        cfg_filename = os.path.join(base, 'setup.cfg') 
+        setopt.edit_config(cfg_filename, settings) 
+ 
+    def update_pth(self, dist): 
+        if self.pth_file is None: 
+            return 
+ 
+        for d in self.pth_file[dist.key]:  # drop old entries 
+            if self.multi_version or d.location != dist.location: 
+                log.info("Removing %s from easy-install.pth file", d) 
+                self.pth_file.remove(d) 
+                if d.location in self.shadow_path: 
+                    self.shadow_path.remove(d.location) 
+ 
+        if not self.multi_version: 
+            if dist.location in self.pth_file.paths: 
+                log.info( 
+                    "%s is already the active version in easy-install.pth", 
                     dist,
-                )
-            else:
-                log.info("Adding %s to easy-install.pth file", dist)
-                self.pth_file.add(dist)  # add new entry
-                if dist.location not in self.shadow_path:
-                    self.shadow_path.append(dist.location)
-
-        if not self.dry_run:
-
-            self.pth_file.save()
-
-            if dist.key == 'setuptools':
-                # Ensure that setuptools itself never becomes unavailable!
-                # XXX should this check for latest version?
-                filename = os.path.join(self.install_dir, 'setuptools.pth')
-                if os.path.islink(filename):
-                    os.unlink(filename)
-                f = open(filename, 'wt')
-                f.write(self.pth_file.make_relative(dist.location) + '\n')
-                f.close()
-
-    def unpack_progress(self, src, dst):
-        # Progress filter for unpacking
-        log.debug("Unpacking %s to %s", src, dst)
-        return dst  # only unpack-and-compile skips files for dry run
-
-    def unpack_and_compile(self, egg_path, destination):
-        to_compile = []
-        to_chmod = []
-
-        def pf(src, dst):
-            if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
-                to_compile.append(dst)
-            elif dst.endswith('.dll') or dst.endswith('.so'):
-                to_chmod.append(dst)
-            self.unpack_progress(src, dst)
-            return not self.dry_run and dst or None
-
-        unpack_archive(egg_path, destination, pf)
-        self.byte_compile(to_compile)
-        if not self.dry_run:
-            for f in to_chmod:
-                mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755
-                chmod(f, mode)
-
-    def byte_compile(self, to_compile):
-        if sys.dont_write_bytecode:
-            return
-
-        from distutils.util import byte_compile
-
-        try:
-            # try to make the byte compile messages quieter
-            log.set_verbosity(self.verbose - 1)
-
-            byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run)
-            if self.optimize:
-                byte_compile(
-                    to_compile, optimize=self.optimize, force=1,
+                ) 
+            else: 
+                log.info("Adding %s to easy-install.pth file", dist) 
+                self.pth_file.add(dist)  # add new entry 
+                if dist.location not in self.shadow_path: 
+                    self.shadow_path.append(dist.location) 
+ 
+        if not self.dry_run: 
+ 
+            self.pth_file.save() 
+ 
+            if dist.key == 'setuptools': 
+                # Ensure that setuptools itself never becomes unavailable! 
+                # XXX should this check for latest version? 
+                filename = os.path.join(self.install_dir, 'setuptools.pth') 
+                if os.path.islink(filename): 
+                    os.unlink(filename) 
+                f = open(filename, 'wt') 
+                f.write(self.pth_file.make_relative(dist.location) + '\n') 
+                f.close() 
+ 
+    def unpack_progress(self, src, dst): 
+        # Progress filter for unpacking 
+        log.debug("Unpacking %s to %s", src, dst) 
+        return dst  # only unpack-and-compile skips files for dry run 
+ 
+    def unpack_and_compile(self, egg_path, destination): 
+        to_compile = [] 
+        to_chmod = [] 
+ 
+        def pf(src, dst): 
+            if dst.endswith('.py') and not src.startswith('EGG-INFO/'): 
+                to_compile.append(dst) 
+            elif dst.endswith('.dll') or dst.endswith('.so'): 
+                to_chmod.append(dst) 
+            self.unpack_progress(src, dst) 
+            return not self.dry_run and dst or None 
+ 
+        unpack_archive(egg_path, destination, pf) 
+        self.byte_compile(to_compile) 
+        if not self.dry_run: 
+            for f in to_chmod: 
+                mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755 
+                chmod(f, mode) 
+ 
+    def byte_compile(self, to_compile): 
+        if sys.dont_write_bytecode: 
+            return 
+ 
+        from distutils.util import byte_compile 
+ 
+        try: 
+            # try to make the byte compile messages quieter 
+            log.set_verbosity(self.verbose - 1) 
+ 
+            byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run) 
+            if self.optimize: 
+                byte_compile( 
+                    to_compile, optimize=self.optimize, force=1, 
                     dry_run=self.dry_run,
-                )
-        finally:
-            log.set_verbosity(self.verbose)  # restore original verbosity
-
-    __no_default_msg = textwrap.dedent("""
-        bad install directory or PYTHONPATH
-
-        You are attempting to install a package to a directory that is not
-        on PYTHONPATH and which Python does not read ".pth" files from.  The
-        installation directory you specified (via --install-dir, --prefix, or
-        the distutils default setting) was:
-
-            %s
-
-        and your PYTHONPATH environment variable currently contains:
-
-            %r
-
-        Here are some of your options for correcting the problem:
-
-        * You can choose a different installation directory, i.e., one that is
-          on PYTHONPATH or supports .pth files
-
-        * You can add the installation directory to the PYTHONPATH environment
-          variable.  (It must then also be on PYTHONPATH whenever you run
-          Python and want to use the package(s) you are installing.)
-
-        * You can set up the installation directory to support ".pth" files by
-          using one of the approaches described here:
-
+                ) 
+        finally: 
+            log.set_verbosity(self.verbose)  # restore original verbosity 
+ 
+    __no_default_msg = textwrap.dedent(""" 
+        bad install directory or PYTHONPATH 
+ 
+        You are attempting to install a package to a directory that is not 
+        on PYTHONPATH and which Python does not read ".pth" files from.  The 
+        installation directory you specified (via --install-dir, --prefix, or 
+        the distutils default setting) was: 
+ 
+            %s 
+ 
+        and your PYTHONPATH environment variable currently contains: 
+ 
+            %r 
+ 
+        Here are some of your options for correcting the problem: 
+ 
+        * You can choose a different installation directory, i.e., one that is 
+          on PYTHONPATH or supports .pth files 
+ 
+        * You can add the installation directory to the PYTHONPATH environment 
+          variable.  (It must then also be on PYTHONPATH whenever you run 
+          Python and want to use the package(s) you are installing.) 
+ 
+        * You can set up the installation directory to support ".pth" files by 
+          using one of the approaches described here: 
+ 
           https://setuptools.readthedocs.io/en/latest/easy_install.html#custom-installation-locations
-
-
-        Please make the appropriate changes for your system and try again.""").lstrip()
-
-    def no_default_version_msg(self):
-        template = self.__no_default_msg
-        return template % (self.install_dir, os.environ.get('PYTHONPATH', ''))
-
-    def install_site_py(self):
-        """Make sure there's a site.py in the target dir, if needed"""
-
-        if self.sitepy_installed:
-            return  # already did it, or don't need to
-
-        sitepy = os.path.join(self.install_dir, "site.py")
-        source = resource_string("setuptools", "site-patch.py")
+ 
+
+        Please make the appropriate changes for your system and try again.""").lstrip() 
+ 
+    def no_default_version_msg(self): 
+        template = self.__no_default_msg 
+        return template % (self.install_dir, os.environ.get('PYTHONPATH', '')) 
+ 
+    def install_site_py(self): 
+        """Make sure there's a site.py in the target dir, if needed""" 
+ 
+        if self.sitepy_installed: 
+            return  # already did it, or don't need to 
+ 
+        sitepy = os.path.join(self.install_dir, "site.py") 
+        source = resource_string("setuptools", "site-patch.py") 
         source = source.decode('utf-8')
-        current = ""
-
-        if os.path.exists(sitepy):
-            log.debug("Checking existing site.py in %s", self.install_dir)
+        current = "" 
+ 
+        if os.path.exists(sitepy): 
+            log.debug("Checking existing site.py in %s", self.install_dir) 
             with io.open(sitepy) as strm:
                 current = strm.read()
-
-            if not current.startswith('def __boot():'):
-                raise DistutilsError(
-                    "%s is not a setuptools-generated site.py; please"
-                    " remove it." % sitepy
-                )
-
-        if current != source:
-            log.info("Creating %s", sitepy)
-            if not self.dry_run:
-                ensure_directory(sitepy)
+ 
+            if not current.startswith('def __boot():'): 
+                raise DistutilsError( 
+                    "%s is not a setuptools-generated site.py; please" 
+                    " remove it." % sitepy 
+                ) 
+ 
+        if current != source: 
+            log.info("Creating %s", sitepy) 
+            if not self.dry_run: 
+                ensure_directory(sitepy) 
                 with io.open(sitepy, 'w', encoding='utf-8') as strm:
                     strm.write(source)
-            self.byte_compile([sitepy])
-
-        self.sitepy_installed = True
-
-    def create_home_path(self):
-        """Create directories under ~."""
-        if not self.user:
-            return
-        home = convert_path(os.path.expanduser("~"))
-        for name, path in six.iteritems(self.config_vars):
-            if path.startswith(home) and not os.path.isdir(path):
-                self.debug_print("os.makedirs('%s', 0o700)" % path)
-                os.makedirs(path, 0o700)
-
-    INSTALL_SCHEMES = dict(
-        posix=dict(
-            install_dir='$base/lib/python$py_version_short/site-packages',
-            script_dir='$base/bin',
-        ),
-    )
-
-    DEFAULT_SCHEME = dict(
-        install_dir='$base/Lib/site-packages',
-        script_dir='$base/Scripts',
-    )
-
-    def _expand(self, *attrs):
-        config_vars = self.get_finalized_command('install').config_vars
-
-        if self.prefix:
-            # Set default install_dir/scripts from --prefix
-            config_vars = config_vars.copy()
-            config_vars['base'] = self.prefix
-            scheme = self.INSTALL_SCHEMES.get(os.name, self.DEFAULT_SCHEME)
-            for attr, val in scheme.items():
-                if getattr(self, attr, None) is None:
-                    setattr(self, attr, val)
-
-        from distutils.util import subst_vars
-
-        for attr in attrs:
-            val = getattr(self, attr)
-            if val is not None:
-                val = subst_vars(val, config_vars)
-                if os.name == 'posix':
-                    val = os.path.expanduser(val)
-                setattr(self, attr, val)
-
-
+            self.byte_compile([sitepy]) 
+ 
+        self.sitepy_installed = True 
+ 
+    def create_home_path(self): 
+        """Create directories under ~.""" 
+        if not self.user: 
+            return 
+        home = convert_path(os.path.expanduser("~")) 
+        for name, path in six.iteritems(self.config_vars): 
+            if path.startswith(home) and not os.path.isdir(path): 
+                self.debug_print("os.makedirs('%s', 0o700)" % path) 
+                os.makedirs(path, 0o700) 
+ 
+    INSTALL_SCHEMES = dict( 
+        posix=dict( 
+            install_dir='$base/lib/python$py_version_short/site-packages', 
+            script_dir='$base/bin', 
+        ), 
+    ) 
+ 
+    DEFAULT_SCHEME = dict( 
+        install_dir='$base/Lib/site-packages', 
+        script_dir='$base/Scripts', 
+    ) 
+ 
+    def _expand(self, *attrs): 
+        config_vars = self.get_finalized_command('install').config_vars 
+ 
+        if self.prefix: 
+            # Set default install_dir/scripts from --prefix 
+            config_vars = config_vars.copy() 
+            config_vars['base'] = self.prefix 
+            scheme = self.INSTALL_SCHEMES.get(os.name, self.DEFAULT_SCHEME) 
+            for attr, val in scheme.items(): 
+                if getattr(self, attr, None) is None: 
+                    setattr(self, attr, val) 
+ 
+        from distutils.util import subst_vars 
+ 
+        for attr in attrs: 
+            val = getattr(self, attr) 
+            if val is not None: 
+                val = subst_vars(val, config_vars) 
+                if os.name == 'posix': 
+                    val = os.path.expanduser(val) 
+                setattr(self, attr, val) 
+ 
+ 
 def _pythonpath():
     items = os.environ.get('PYTHONPATH', '').split(os.pathsep)
     return filter(None, items)
 
 
-def get_site_dirs():
+def get_site_dirs(): 
     """
     Return a list of 'site' dirs
     """
@@ -1405,14 +1405,14 @@ def get_site_dirs():
     # start with PYTHONPATH
     sitedirs.extend(_pythonpath())
 
-    prefixes = [sys.prefix]
-    if sys.exec_prefix != sys.prefix:
-        prefixes.append(sys.exec_prefix)
-    for prefix in prefixes:
-        if prefix:
-            if sys.platform in ('os2emx', 'riscos'):
-                sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
-            elif os.sep == '/':
+    prefixes = [sys.prefix] 
+    if sys.exec_prefix != sys.prefix: 
+        prefixes.append(sys.exec_prefix) 
+    for prefix in prefixes: 
+        if prefix: 
+            if sys.platform in ('os2emx', 'riscos'): 
+                sitedirs.append(os.path.join(prefix, "Lib", "site-packages")) 
+            elif os.sep == '/': 
                 sitedirs.extend([
                     os.path.join(
                         prefix,
@@ -1422,18 +1422,18 @@ def get_site_dirs():
                     ),
                     os.path.join(prefix, "lib", "site-python"),
                 ])
-            else:
+            else: 
                 sitedirs.extend([
                     prefix,
                     os.path.join(prefix, "lib", "site-packages"),
                 ])
-            if sys.platform == 'darwin':
-                # for framework builds *only* we add the standard Apple
-                # locations. Currently only per-user, but /Library and
-                # /Network/Library could be added too
-                if 'Python.framework' in prefix:
-                    home = os.environ.get('HOME')
-                    if home:
+            if sys.platform == 'darwin': 
+                # for framework builds *only* we add the standard Apple 
+                # locations. Currently only per-user, but /Library and 
+                # /Network/Library could be added too 
+                if 'Python.framework' in prefix: 
+                    home = os.environ.get('HOME') 
+                    if home: 
                         home_sp = os.path.join(
                             home,
                             'Library',
@@ -1442,602 +1442,602 @@ def get_site_dirs():
                             'site-packages',
                         )
                         sitedirs.append(home_sp)
-    lib_paths = get_path('purelib'), get_path('platlib')
-    for site_lib in lib_paths:
-        if site_lib not in sitedirs:
-            sitedirs.append(site_lib)
-
-    if site.ENABLE_USER_SITE:
-        sitedirs.append(site.USER_SITE)
-
+    lib_paths = get_path('purelib'), get_path('platlib') 
+    for site_lib in lib_paths: 
+        if site_lib not in sitedirs: 
+            sitedirs.append(site_lib) 
+ 
+    if site.ENABLE_USER_SITE: 
+        sitedirs.append(site.USER_SITE) 
+ 
     try:
         sitedirs.extend(site.getsitepackages())
     except AttributeError:
         pass
 
-    sitedirs = list(map(normalize_path, sitedirs))
-
-    return sitedirs
-
-
-def expand_paths(inputs):
-    """Yield sys.path directories that might contain "old-style" packages"""
-
-    seen = {}
-
-    for dirname in inputs:
-        dirname = normalize_path(dirname)
-        if dirname in seen:
-            continue
-
-        seen[dirname] = 1
-        if not os.path.isdir(dirname):
-            continue
-
-        files = os.listdir(dirname)
-        yield dirname, files
-
-        for name in files:
-            if not name.endswith('.pth'):
-                # We only care about the .pth files
-                continue
-            if name in ('easy-install.pth', 'setuptools.pth'):
-                # Ignore .pth files that we control
-                continue
-
-            # Read the .pth file
-            f = open(os.path.join(dirname, name))
-            lines = list(yield_lines(f))
-            f.close()
-
-            # Yield existing non-dupe, non-import directory lines from it
-            for line in lines:
-                if not line.startswith("import"):
-                    line = normalize_path(line.rstrip())
-                    if line not in seen:
-                        seen[line] = 1
-                        if not os.path.isdir(line):
-                            continue
-                        yield line, os.listdir(line)
-
-
-def extract_wininst_cfg(dist_filename):
-    """Extract configuration data from a bdist_wininst .exe
-
-    Returns a configparser.RawConfigParser, or None
-    """
-    f = open(dist_filename, 'rb')
-    try:
-        endrec = zipfile._EndRecData(f)
-        if endrec is None:
-            return None
-
-        prepended = (endrec[9] - endrec[5]) - endrec[6]
-        if prepended < 12:  # no wininst data here
-            return None
-        f.seek(prepended - 12)
-
-        tag, cfglen, bmlen = struct.unpack("<iii", f.read(12))
-        if tag not in (0x1234567A, 0x1234567B):
-            return None  # not a valid tag
-
-        f.seek(prepended - (12 + cfglen))
+    sitedirs = list(map(normalize_path, sitedirs)) 
+ 
+    return sitedirs 
+ 
+ 
+def expand_paths(inputs): 
+    """Yield sys.path directories that might contain "old-style" packages""" 
+ 
+    seen = {} 
+ 
+    for dirname in inputs: 
+        dirname = normalize_path(dirname) 
+        if dirname in seen: 
+            continue 
+ 
+        seen[dirname] = 1 
+        if not os.path.isdir(dirname): 
+            continue 
+ 
+        files = os.listdir(dirname) 
+        yield dirname, files 
+ 
+        for name in files: 
+            if not name.endswith('.pth'): 
+                # We only care about the .pth files 
+                continue 
+            if name in ('easy-install.pth', 'setuptools.pth'): 
+                # Ignore .pth files that we control 
+                continue 
+ 
+            # Read the .pth file 
+            f = open(os.path.join(dirname, name)) 
+            lines = list(yield_lines(f)) 
+            f.close() 
+ 
+            # Yield existing non-dupe, non-import directory lines from it 
+            for line in lines: 
+                if not line.startswith("import"): 
+                    line = normalize_path(line.rstrip()) 
+                    if line not in seen: 
+                        seen[line] = 1 
+                        if not os.path.isdir(line): 
+                            continue 
+                        yield line, os.listdir(line) 
+ 
+ 
+def extract_wininst_cfg(dist_filename): 
+    """Extract configuration data from a bdist_wininst .exe 
+ 
+    Returns a configparser.RawConfigParser, or None 
+    """ 
+    f = open(dist_filename, 'rb') 
+    try: 
+        endrec = zipfile._EndRecData(f) 
+        if endrec is None: 
+            return None 
+ 
+        prepended = (endrec[9] - endrec[5]) - endrec[6] 
+        if prepended < 12:  # no wininst data here 
+            return None 
+        f.seek(prepended - 12) 
+ 
+        tag, cfglen, bmlen = struct.unpack("<iii", f.read(12)) 
+        if tag not in (0x1234567A, 0x1234567B): 
+            return None  # not a valid tag 
+ 
+        f.seek(prepended - (12 + cfglen)) 
         init = {'version': '', 'target_version': ''}
         cfg = configparser.RawConfigParser(init)
-        try:
-            part = f.read(cfglen)
-            # Read up to the first null byte.
-            config = part.split(b'\0', 1)[0]
-            # Now the config is in bytes, but for RawConfigParser, it should
-            #  be text, so decode it.
-            config = config.decode(sys.getfilesystemencoding())
-            cfg.readfp(six.StringIO(config))
-        except configparser.Error:
-            return None
-        if not cfg.has_section('metadata') or not cfg.has_section('Setup'):
-            return None
-        return cfg
-
-    finally:
-        f.close()
-
-
-def get_exe_prefixes(exe_filename):
-    """Get exe->egg path translations for a given .exe file"""
-
-    prefixes = [
+        try: 
+            part = f.read(cfglen) 
+            # Read up to the first null byte. 
+            config = part.split(b'\0', 1)[0] 
+            # Now the config is in bytes, but for RawConfigParser, it should 
+            #  be text, so decode it. 
+            config = config.decode(sys.getfilesystemencoding()) 
+            cfg.readfp(six.StringIO(config)) 
+        except configparser.Error: 
+            return None 
+        if not cfg.has_section('metadata') or not cfg.has_section('Setup'): 
+            return None 
+        return cfg 
+ 
+    finally: 
+        f.close() 
+ 
+ 
+def get_exe_prefixes(exe_filename): 
+    """Get exe->egg path translations for a given .exe file""" 
+ 
+    prefixes = [ 
         ('PURELIB/', ''),
         ('PLATLIB/pywin32_system32', ''),
-        ('PLATLIB/', ''),
-        ('SCRIPTS/', 'EGG-INFO/scripts/'),
-        ('DATA/lib/site-packages', ''),
-    ]
-    z = zipfile.ZipFile(exe_filename)
-    try:
-        for info in z.infolist():
-            name = info.filename
-            parts = name.split('/')
-            if len(parts) == 3 and parts[2] == 'PKG-INFO':
-                if parts[1].endswith('.egg-info'):
-                    prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/'))
-                    break
-            if len(parts) != 2 or not name.endswith('.pth'):
-                continue
-            if name.endswith('-nspkg.pth'):
-                continue
-            if parts[0].upper() in ('PURELIB', 'PLATLIB'):
-                contents = z.read(name)
+        ('PLATLIB/', ''), 
+        ('SCRIPTS/', 'EGG-INFO/scripts/'), 
+        ('DATA/lib/site-packages', ''), 
+    ] 
+    z = zipfile.ZipFile(exe_filename) 
+    try: 
+        for info in z.infolist(): 
+            name = info.filename 
+            parts = name.split('/') 
+            if len(parts) == 3 and parts[2] == 'PKG-INFO': 
+                if parts[1].endswith('.egg-info'): 
+                    prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/')) 
+                    break 
+            if len(parts) != 2 or not name.endswith('.pth'): 
+                continue 
+            if name.endswith('-nspkg.pth'): 
+                continue 
+            if parts[0].upper() in ('PURELIB', 'PLATLIB'): 
+                contents = z.read(name) 
                 if not six.PY2:
-                    contents = contents.decode()
-                for pth in yield_lines(contents):
-                    pth = pth.strip().replace('\\', '/')
-                    if not pth.startswith('import'):
-                        prefixes.append((('%s/%s/' % (parts[0], pth)), ''))
-    finally:
-        z.close()
-    prefixes = [(x.lower(), y) for x, y in prefixes]
-    prefixes.sort()
-    prefixes.reverse()
-    return prefixes
-
-
-class PthDistributions(Environment):
-    """A .pth file with Distribution paths in it"""
-
-    dirty = False
-
-    def __init__(self, filename, sitedirs=()):
-        self.filename = filename
-        self.sitedirs = list(map(normalize_path, sitedirs))
-        self.basedir = normalize_path(os.path.dirname(self.filename))
-        self._load()
-        Environment.__init__(self, [], None, None)
-        for path in yield_lines(self.paths):
-            list(map(self.add, find_distributions(path, True)))
-
-    def _load(self):
-        self.paths = []
-        saw_import = False
-        seen = dict.fromkeys(self.sitedirs)
-        if os.path.isfile(self.filename):
-            f = open(self.filename, 'rt')
-            for line in f:
-                if line.startswith('import'):
-                    saw_import = True
-                    continue
-                path = line.rstrip()
-                self.paths.append(path)
-                if not path.strip() or path.strip().startswith('#'):
-                    continue
-                # skip non-existent paths, in case somebody deleted a package
-                # manually, and duplicate paths as well
-                path = self.paths[-1] = normalize_path(
-                    os.path.join(self.basedir, path)
-                )
-                if not os.path.exists(path) or path in seen:
-                    self.paths.pop()  # skip it
-                    self.dirty = True  # we cleaned up, so we're dirty now :)
-                    continue
-                seen[path] = 1
-            f.close()
-
-        if self.paths and not saw_import:
-            self.dirty = True  # ensure anything we touch has import wrappers
-        while self.paths and not self.paths[-1].strip():
-            self.paths.pop()
-
-    def save(self):
-        """Write changed .pth file back to disk"""
-        if not self.dirty:
-            return
-
-        rel_paths = list(map(self.make_relative, self.paths))
-        if rel_paths:
-            log.debug("Saving %s", self.filename)
-            lines = self._wrap_lines(rel_paths)
-            data = '\n'.join(lines) + '\n'
-
-            if os.path.islink(self.filename):
-                os.unlink(self.filename)
-            with open(self.filename, 'wt') as f:
-                f.write(data)
-
-        elif os.path.exists(self.filename):
-            log.debug("Deleting empty %s", self.filename)
-            os.unlink(self.filename)
-
-        self.dirty = False
-
-    @staticmethod
-    def _wrap_lines(lines):
-        return lines
-
-    def add(self, dist):
-        """Add `dist` to the distribution map"""
-        new_path = (
-            dist.location not in self.paths and (
-                dist.location not in self.sitedirs or
-                # account for '.' being in PYTHONPATH
-                dist.location == os.getcwd()
-            )
-        )
-        if new_path:
-            self.paths.append(dist.location)
-            self.dirty = True
-        Environment.add(self, dist)
-
-    def remove(self, dist):
-        """Remove `dist` from the distribution map"""
-        while dist.location in self.paths:
-            self.paths.remove(dist.location)
-            self.dirty = True
-        Environment.remove(self, dist)
-
-    def make_relative(self, path):
-        npath, last = os.path.split(normalize_path(path))
-        baselen = len(self.basedir)
-        parts = [last]
-        sep = os.altsep == '/' and '/' or os.sep
-        while len(npath) >= baselen:
-            if npath == self.basedir:
-                parts.append(os.curdir)
-                parts.reverse()
-                return sep.join(parts)
-            npath, last = os.path.split(npath)
-            parts.append(last)
-        else:
-            return path
-
-
-class RewritePthDistributions(PthDistributions):
-    @classmethod
-    def _wrap_lines(cls, lines):
-        yield cls.prelude
-        for line in lines:
-            yield line
-        yield cls.postlude
-
+                    contents = contents.decode() 
+                for pth in yield_lines(contents): 
+                    pth = pth.strip().replace('\\', '/') 
+                    if not pth.startswith('import'): 
+                        prefixes.append((('%s/%s/' % (parts[0], pth)), '')) 
+    finally: 
+        z.close() 
+    prefixes = [(x.lower(), y) for x, y in prefixes] 
+    prefixes.sort() 
+    prefixes.reverse() 
+    return prefixes 
+ 
+ 
+class PthDistributions(Environment): 
+    """A .pth file with Distribution paths in it""" 
+ 
+    dirty = False 
+ 
+    def __init__(self, filename, sitedirs=()): 
+        self.filename = filename 
+        self.sitedirs = list(map(normalize_path, sitedirs)) 
+        self.basedir = normalize_path(os.path.dirname(self.filename)) 
+        self._load() 
+        Environment.__init__(self, [], None, None) 
+        for path in yield_lines(self.paths): 
+            list(map(self.add, find_distributions(path, True))) 
+ 
+    def _load(self): 
+        self.paths = [] 
+        saw_import = False 
+        seen = dict.fromkeys(self.sitedirs) 
+        if os.path.isfile(self.filename): 
+            f = open(self.filename, 'rt') 
+            for line in f: 
+                if line.startswith('import'): 
+                    saw_import = True 
+                    continue 
+                path = line.rstrip() 
+                self.paths.append(path) 
+                if not path.strip() or path.strip().startswith('#'): 
+                    continue 
+                # skip non-existent paths, in case somebody deleted a package 
+                # manually, and duplicate paths as well 
+                path = self.paths[-1] = normalize_path( 
+                    os.path.join(self.basedir, path) 
+                ) 
+                if not os.path.exists(path) or path in seen: 
+                    self.paths.pop()  # skip it 
+                    self.dirty = True  # we cleaned up, so we're dirty now :) 
+                    continue 
+                seen[path] = 1 
+            f.close() 
+ 
+        if self.paths and not saw_import: 
+            self.dirty = True  # ensure anything we touch has import wrappers 
+        while self.paths and not self.paths[-1].strip(): 
+            self.paths.pop() 
+ 
+    def save(self): 
+        """Write changed .pth file back to disk""" 
+        if not self.dirty: 
+            return 
+ 
+        rel_paths = list(map(self.make_relative, self.paths)) 
+        if rel_paths: 
+            log.debug("Saving %s", self.filename) 
+            lines = self._wrap_lines(rel_paths) 
+            data = '\n'.join(lines) + '\n' 
+ 
+            if os.path.islink(self.filename): 
+                os.unlink(self.filename) 
+            with open(self.filename, 'wt') as f: 
+                f.write(data) 
+ 
+        elif os.path.exists(self.filename): 
+            log.debug("Deleting empty %s", self.filename) 
+            os.unlink(self.filename) 
+ 
+        self.dirty = False 
+ 
+    @staticmethod 
+    def _wrap_lines(lines): 
+        return lines 
+ 
+    def add(self, dist): 
+        """Add `dist` to the distribution map""" 
+        new_path = ( 
+            dist.location not in self.paths and ( 
+                dist.location not in self.sitedirs or 
+                # account for '.' being in PYTHONPATH 
+                dist.location == os.getcwd() 
+            ) 
+        ) 
+        if new_path: 
+            self.paths.append(dist.location) 
+            self.dirty = True 
+        Environment.add(self, dist) 
+ 
+    def remove(self, dist): 
+        """Remove `dist` from the distribution map""" 
+        while dist.location in self.paths: 
+            self.paths.remove(dist.location) 
+            self.dirty = True 
+        Environment.remove(self, dist) 
+ 
+    def make_relative(self, path): 
+        npath, last = os.path.split(normalize_path(path)) 
+        baselen = len(self.basedir) 
+        parts = [last] 
+        sep = os.altsep == '/' and '/' or os.sep 
+        while len(npath) >= baselen: 
+            if npath == self.basedir: 
+                parts.append(os.curdir) 
+                parts.reverse() 
+                return sep.join(parts) 
+            npath, last = os.path.split(npath) 
+            parts.append(last) 
+        else: 
+            return path 
+ 
+ 
+class RewritePthDistributions(PthDistributions): 
+    @classmethod 
+    def _wrap_lines(cls, lines): 
+        yield cls.prelude 
+        for line in lines: 
+            yield line 
+        yield cls.postlude 
+ 
     prelude = _one_liner("""
-        import sys
-        sys.__plen = len(sys.path)
-        """)
+        import sys 
+        sys.__plen = len(sys.path) 
+        """) 
     postlude = _one_liner("""
-        import sys
-        new = sys.path[sys.__plen:]
-        del sys.path[sys.__plen:]
-        p = getattr(sys, '__egginsert', 0)
-        sys.path[p:p] = new
-        sys.__egginsert = p + len(new)
-        """)
-
-
+        import sys 
+        new = sys.path[sys.__plen:] 
+        del sys.path[sys.__plen:] 
+        p = getattr(sys, '__egginsert', 0) 
+        sys.path[p:p] = new 
+        sys.__egginsert = p + len(new) 
+        """) 
+ 
+ 
 if os.environ.get('SETUPTOOLS_SYS_PATH_TECHNIQUE', 'raw') == 'rewrite':
-    PthDistributions = RewritePthDistributions
-
-
-def _first_line_re():
-    """
-    Return a regular expression based on first_line_re suitable for matching
-    strings.
-    """
-    if isinstance(first_line_re.pattern, str):
-        return first_line_re
-
-    # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern.
-    return re.compile(first_line_re.pattern.decode())
-
-
-def auto_chmod(func, arg, exc):
+    PthDistributions = RewritePthDistributions 
+ 
+ 
+def _first_line_re(): 
+    """ 
+    Return a regular expression based on first_line_re suitable for matching 
+    strings. 
+    """ 
+    if isinstance(first_line_re.pattern, str): 
+        return first_line_re 
+ 
+    # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern. 
+    return re.compile(first_line_re.pattern.decode()) 
+ 
+ 
+def auto_chmod(func, arg, exc): 
     if func in [os.unlink, os.remove] and os.name == 'nt':
-        chmod(arg, stat.S_IWRITE)
-        return func(arg)
-    et, ev, _ = sys.exc_info()
-    six.reraise(et, (ev[0], ev[1] + (" %s %s" % (func, arg))))
-
-
-def update_dist_caches(dist_path, fix_zipimporter_caches):
-    """
-    Fix any globally cached `dist_path` related data
-
-    `dist_path` should be a path of a newly installed egg distribution (zipped
-    or unzipped).
-
-    sys.path_importer_cache contains finder objects that have been cached when
-    importing data from the original distribution. Any such finders need to be
-    cleared since the replacement distribution might be packaged differently,
-    e.g. a zipped egg distribution might get replaced with an unzipped egg
-    folder or vice versa. Having the old finders cached may then cause Python
-    to attempt loading modules from the replacement distribution using an
-    incorrect loader.
-
-    zipimport.zipimporter objects are Python loaders charged with importing
-    data packaged inside zip archives. If stale loaders referencing the
-    original distribution, are left behind, they can fail to load modules from
-    the replacement distribution. E.g. if an old zipimport.zipimporter instance
-    is used to load data from a new zipped egg archive, it may cause the
-    operation to attempt to locate the requested data in the wrong location -
-    one indicated by the original distribution's zip archive directory
-    information. Such an operation may then fail outright, e.g. report having
-    read a 'bad local file header', or even worse, it may fail silently &
-    return invalid data.
-
-    zipimport._zip_directory_cache contains cached zip archive directory
-    information for all existing zipimport.zipimporter instances and all such
-    instances connected to the same archive share the same cached directory
-    information.
-
-    If asked, and the underlying Python implementation allows it, we can fix
-    all existing zipimport.zipimporter instances instead of having to track
-    them down and remove them one by one, by updating their shared cached zip
-    archive directory information. This, of course, assumes that the
-    replacement distribution is packaged as a zipped egg.
-
-    If not asked to fix existing zipimport.zipimporter instances, we still do
-    our best to clear any remaining zipimport.zipimporter related cached data
-    that might somehow later get used when attempting to load data from the new
-    distribution and thus cause such load operations to fail. Note that when
-    tracking down such remaining stale data, we can not catch every conceivable
-    usage from here, and we clear only those that we know of and have found to
-    cause problems if left alive. Any remaining caches should be updated by
-    whomever is in charge of maintaining them, i.e. they should be ready to
-    handle us replacing their zip archives with new distributions at runtime.
-
-    """
-    # There are several other known sources of stale zipimport.zipimporter
-    # instances that we do not clear here, but might if ever given a reason to
-    # do so:
-    # * Global setuptools pkg_resources.working_set (a.k.a. 'master working
-    # set') may contain distributions which may in turn contain their
-    #   zipimport.zipimporter loaders.
-    # * Several zipimport.zipimporter loaders held by local variables further
-    #   up the function call stack when running the setuptools installation.
-    # * Already loaded modules may have their __loader__ attribute set to the
-    #   exact loader instance used when importing them. Python 3.4 docs state
-    #   that this information is intended mostly for introspection and so is
-    #   not expected to cause us problems.
-    normalized_path = normalize_path(dist_path)
-    _uncache(normalized_path, sys.path_importer_cache)
-    if fix_zipimporter_caches:
-        _replace_zip_directory_cache_data(normalized_path)
-    else:
-        # Here, even though we do not want to fix existing and now stale
-        # zipimporter cache information, we still want to remove it. Related to
-        # Python's zip archive directory information cache, we clear each of
-        # its stale entries in two phases:
-        #   1. Clear the entry so attempting to access zip archive information
-        #      via any existing stale zipimport.zipimporter instances fails.
-        #   2. Remove the entry from the cache so any newly constructed
-        #      zipimport.zipimporter instances do not end up using old stale
-        #      zip archive directory information.
-        # This whole stale data removal step does not seem strictly necessary,
-        # but has been left in because it was done before we started replacing
-        # the zip archive directory information cache content if possible, and
-        # there are no relevant unit tests that we can depend on to tell us if
-        # this is really needed.
-        _remove_and_clear_zip_directory_cache_data(normalized_path)
-
-
-def _collect_zipimporter_cache_entries(normalized_path, cache):
-    """
-    Return zipimporter cache entry keys related to a given normalized path.
-
-    Alternative path spellings (e.g. those using different character case or
-    those using alternative path separators) related to the same path are
-    included. Any sub-path entries are included as well, i.e. those
-    corresponding to zip archives embedded in other zip archives.
-
-    """
-    result = []
-    prefix_len = len(normalized_path)
-    for p in cache:
-        np = normalize_path(p)
-        if (np.startswith(normalized_path) and
-                np[prefix_len:prefix_len + 1] in (os.sep, '')):
-            result.append(p)
-    return result
-
-
-def _update_zipimporter_cache(normalized_path, cache, updater=None):
-    """
-    Update zipimporter cache data for a given normalized path.
-
-    Any sub-path entries are processed as well, i.e. those corresponding to zip
-    archives embedded in other zip archives.
-
-    Given updater is a callable taking a cache entry key and the original entry
-    (after already removing the entry from the cache), and expected to update
-    the entry and possibly return a new one to be inserted in its place.
-    Returning None indicates that the entry should not be replaced with a new
-    one. If no updater is given, the cache entries are simply removed without
-    any additional processing, the same as if the updater simply returned None.
-
-    """
-    for p in _collect_zipimporter_cache_entries(normalized_path, cache):
-        # N.B. pypy's custom zipimport._zip_directory_cache implementation does
-        # not support the complete dict interface:
-        # * Does not support item assignment, thus not allowing this function
-        #    to be used only for removing existing cache entries.
-        #  * Does not support the dict.pop() method, forcing us to use the
-        #    get/del patterns instead. For more detailed information see the
-        #    following links:
+        chmod(arg, stat.S_IWRITE) 
+        return func(arg) 
+    et, ev, _ = sys.exc_info() 
+    six.reraise(et, (ev[0], ev[1] + (" %s %s" % (func, arg)))) 
+ 
+ 
+def update_dist_caches(dist_path, fix_zipimporter_caches): 
+    """ 
+    Fix any globally cached `dist_path` related data 
+ 
+    `dist_path` should be a path of a newly installed egg distribution (zipped 
+    or unzipped). 
+ 
+    sys.path_importer_cache contains finder objects that have been cached when 
+    importing data from the original distribution. Any such finders need to be 
+    cleared since the replacement distribution might be packaged differently, 
+    e.g. a zipped egg distribution might get replaced with an unzipped egg 
+    folder or vice versa. Having the old finders cached may then cause Python 
+    to attempt loading modules from the replacement distribution using an 
+    incorrect loader. 
+ 
+    zipimport.zipimporter objects are Python loaders charged with importing 
+    data packaged inside zip archives. If stale loaders referencing the 
+    original distribution, are left behind, they can fail to load modules from 
+    the replacement distribution. E.g. if an old zipimport.zipimporter instance 
+    is used to load data from a new zipped egg archive, it may cause the 
+    operation to attempt to locate the requested data in the wrong location - 
+    one indicated by the original distribution's zip archive directory 
+    information. Such an operation may then fail outright, e.g. report having 
+    read a 'bad local file header', or even worse, it may fail silently & 
+    return invalid data. 
+ 
+    zipimport._zip_directory_cache contains cached zip archive directory 
+    information for all existing zipimport.zipimporter instances and all such 
+    instances connected to the same archive share the same cached directory 
+    information. 
+ 
+    If asked, and the underlying Python implementation allows it, we can fix 
+    all existing zipimport.zipimporter instances instead of having to track 
+    them down and remove them one by one, by updating their shared cached zip 
+    archive directory information. This, of course, assumes that the 
+    replacement distribution is packaged as a zipped egg. 
+ 
+    If not asked to fix existing zipimport.zipimporter instances, we still do 
+    our best to clear any remaining zipimport.zipimporter related cached data 
+    that might somehow later get used when attempting to load data from the new 
+    distribution and thus cause such load operations to fail. Note that when 
+    tracking down such remaining stale data, we can not catch every conceivable 
+    usage from here, and we clear only those that we know of and have found to 
+    cause problems if left alive. Any remaining caches should be updated by 
+    whomever is in charge of maintaining them, i.e. they should be ready to 
+    handle us replacing their zip archives with new distributions at runtime. 
+ 
+    """ 
+    # There are several other known sources of stale zipimport.zipimporter 
+    # instances that we do not clear here, but might if ever given a reason to 
+    # do so: 
+    # * Global setuptools pkg_resources.working_set (a.k.a. 'master working 
+    # set') may contain distributions which may in turn contain their 
+    #   zipimport.zipimporter loaders. 
+    # * Several zipimport.zipimporter loaders held by local variables further 
+    #   up the function call stack when running the setuptools installation. 
+    # * Already loaded modules may have their __loader__ attribute set to the 
+    #   exact loader instance used when importing them. Python 3.4 docs state 
+    #   that this information is intended mostly for introspection and so is 
+    #   not expected to cause us problems. 
+    normalized_path = normalize_path(dist_path) 
+    _uncache(normalized_path, sys.path_importer_cache) 
+    if fix_zipimporter_caches: 
+        _replace_zip_directory_cache_data(normalized_path) 
+    else: 
+        # Here, even though we do not want to fix existing and now stale 
+        # zipimporter cache information, we still want to remove it. Related to 
+        # Python's zip archive directory information cache, we clear each of 
+        # its stale entries in two phases: 
+        #   1. Clear the entry so attempting to access zip archive information 
+        #      via any existing stale zipimport.zipimporter instances fails. 
+        #   2. Remove the entry from the cache so any newly constructed 
+        #      zipimport.zipimporter instances do not end up using old stale 
+        #      zip archive directory information. 
+        # This whole stale data removal step does not seem strictly necessary, 
+        # but has been left in because it was done before we started replacing 
+        # the zip archive directory information cache content if possible, and 
+        # there are no relevant unit tests that we can depend on to tell us if 
+        # this is really needed. 
+        _remove_and_clear_zip_directory_cache_data(normalized_path) 
+ 
+ 
+def _collect_zipimporter_cache_entries(normalized_path, cache): 
+    """ 
+    Return zipimporter cache entry keys related to a given normalized path. 
+ 
+    Alternative path spellings (e.g. those using different character case or 
+    those using alternative path separators) related to the same path are 
+    included. Any sub-path entries are included as well, i.e. those 
+    corresponding to zip archives embedded in other zip archives. 
+ 
+    """ 
+    result = [] 
+    prefix_len = len(normalized_path) 
+    for p in cache: 
+        np = normalize_path(p) 
+        if (np.startswith(normalized_path) and 
+                np[prefix_len:prefix_len + 1] in (os.sep, '')): 
+            result.append(p) 
+    return result 
+ 
+ 
+def _update_zipimporter_cache(normalized_path, cache, updater=None): 
+    """ 
+    Update zipimporter cache data for a given normalized path. 
+ 
+    Any sub-path entries are processed as well, i.e. those corresponding to zip 
+    archives embedded in other zip archives. 
+ 
+    Given updater is a callable taking a cache entry key and the original entry 
+    (after already removing the entry from the cache), and expected to update 
+    the entry and possibly return a new one to be inserted in its place. 
+    Returning None indicates that the entry should not be replaced with a new 
+    one. If no updater is given, the cache entries are simply removed without 
+    any additional processing, the same as if the updater simply returned None. 
+ 
+    """ 
+    for p in _collect_zipimporter_cache_entries(normalized_path, cache): 
+        # N.B. pypy's custom zipimport._zip_directory_cache implementation does 
+        # not support the complete dict interface: 
+        # * Does not support item assignment, thus not allowing this function 
+        #    to be used only for removing existing cache entries. 
+        #  * Does not support the dict.pop() method, forcing us to use the 
+        #    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
-        old_entry = cache[p]
-        del cache[p]
-        new_entry = updater and updater(p, old_entry)
-        if new_entry is not None:
-            cache[p] = new_entry
-
-
-def _uncache(normalized_path, cache):
-    _update_zipimporter_cache(normalized_path, cache)
-
-
-def _remove_and_clear_zip_directory_cache_data(normalized_path):
-    def clear_and_remove_cached_zip_archive_directory_data(path, old_entry):
-        old_entry.clear()
-
-    _update_zipimporter_cache(
-        normalized_path, zipimport._zip_directory_cache,
-        updater=clear_and_remove_cached_zip_archive_directory_data)
-
-
-# PyPy Python implementation does not allow directly writing to the
-# zipimport._zip_directory_cache and so prevents us from attempting to correct
-# its content. The best we can do there is clear the problematic cache content
-# and have PyPy repopulate it as needed. The downside is that if there are any
-# stale zipimport.zipimporter instances laying around, attempting to use them
-# will fail due to not having its zip archive directory information available
-# instead of being automatically corrected to use the new correct zip archive
-# directory information.
-if '__pypy__' in sys.builtin_module_names:
-    _replace_zip_directory_cache_data = \
-        _remove_and_clear_zip_directory_cache_data
-else:
-
-    def _replace_zip_directory_cache_data(normalized_path):
-        def replace_cached_zip_archive_directory_data(path, old_entry):
-            # N.B. In theory, we could load the zip directory information just
-            # once for all updated path spellings, and then copy it locally and
-            # update its contained path strings to contain the correct
-            # spelling, but that seems like a way too invasive move (this cache
-            # structure is not officially documented anywhere and could in
-            # theory change with new Python releases) for no significant
-            # benefit.
-            old_entry.clear()
-            zipimport.zipimporter(path)
-            old_entry.update(zipimport._zip_directory_cache[path])
-            return old_entry
-
-        _update_zipimporter_cache(
-            normalized_path, zipimport._zip_directory_cache,
-            updater=replace_cached_zip_archive_directory_data)
-
-
-def is_python(text, filename='<string>'):
-    "Is this string a valid Python script?"
-    try:
-        compile(text, filename, 'exec')
-    except (SyntaxError, TypeError):
-        return False
-    else:
-        return True
-
-
-def is_sh(executable):
-    """Determine if the specified executable is a .sh (contains a #! line)"""
-    try:
-        with io.open(executable, encoding='latin-1') as fp:
-            magic = fp.read(2)
-    except (OSError, IOError):
-        return executable
-    return magic == '#!'
-
-
-def nt_quote_arg(arg):
-    """Quote a command line argument according to Windows parsing rules"""
-    return subprocess.list2cmdline([arg])
-
-
-def is_python_script(script_text, filename):
-    """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc.
-    """
-    if filename.endswith('.py') or filename.endswith('.pyw'):
-        return True  # extension says it's Python
-    if is_python(script_text, filename):
-        return True  # it's syntactically valid Python
-    if script_text.startswith('#!'):
-        # It begins with a '#!' line, so check if 'python' is in it somewhere
-        return 'python' in script_text.splitlines()[0].lower()
-
-    return False  # Not any Python I can recognize
-
-
-try:
-    from os import chmod as _chmod
-except ImportError:
-    # Jython compatibility
-    def _chmod(*args):
-        pass
-
-
-def chmod(path, mode):
-    log.debug("changing mode of %s to %o", path, mode)
-    try:
-        _chmod(path, mode)
-    except os.error as e:
-        log.debug("chmod failed: %s", e)
-
-
-class CommandSpec(list):
-    """
-    A command spec for a #! header, specified as a list of arguments akin to
-    those passed to Popen.
-    """
-
-    options = []
-    split_args = dict()
-
-    @classmethod
-    def best(cls):
-        """
-        Choose the best CommandSpec class based on environmental conditions.
-        """
-        return cls
-
-    @classmethod
-    def _sys_executable(cls):
-        _default = os.path.normpath(sys.executable)
-        return os.environ.get('__PYVENV_LAUNCHER__', _default)
-
-    @classmethod
-    def from_param(cls, param):
-        """
-        Construct a CommandSpec from a parameter to build_scripts, which may
-        be None.
-        """
-        if isinstance(param, cls):
-            return param
-        if isinstance(param, list):
-            return cls(param)
-        if param is None:
-            return cls.from_environment()
-        # otherwise, assume it's a string.
-        return cls.from_string(param)
-
-    @classmethod
-    def from_environment(cls):
-        return cls([cls._sys_executable()])
-
-    @classmethod
-    def from_string(cls, string):
-        """
-        Construct a command spec from a simple string representing a command
-        line parseable by shlex.split.
-        """
-        items = shlex.split(string, **cls.split_args)
-        return cls(items)
-
-    def install_options(self, script_text):
-        self.options = shlex.split(self._extract_options(script_text))
-        cmdline = subprocess.list2cmdline(self)
-        if not isascii(cmdline):
-            self.options[:0] = ['-x']
-
-    @staticmethod
-    def _extract_options(orig_script):
-        """
-        Extract any options from the first line of the script.
-        """
-        first = (orig_script + '\n').splitlines()[0]
-        match = _first_line_re().match(first)
-        options = match.group(1) or '' if match else ''
-        return options.strip()
-
-    def as_header(self):
-        return self._render(self + list(self.options))
-
-    @staticmethod
+        old_entry = cache[p] 
+        del cache[p] 
+        new_entry = updater and updater(p, old_entry) 
+        if new_entry is not None: 
+            cache[p] = new_entry 
+ 
+ 
+def _uncache(normalized_path, cache): 
+    _update_zipimporter_cache(normalized_path, cache) 
+ 
+ 
+def _remove_and_clear_zip_directory_cache_data(normalized_path): 
+    def clear_and_remove_cached_zip_archive_directory_data(path, old_entry): 
+        old_entry.clear() 
+ 
+    _update_zipimporter_cache( 
+        normalized_path, zipimport._zip_directory_cache, 
+        updater=clear_and_remove_cached_zip_archive_directory_data) 
+ 
+
+# PyPy Python implementation does not allow directly writing to the 
+# zipimport._zip_directory_cache and so prevents us from attempting to correct 
+# its content. The best we can do there is clear the problematic cache content 
+# and have PyPy repopulate it as needed. The downside is that if there are any 
+# stale zipimport.zipimporter instances laying around, attempting to use them 
+# will fail due to not having its zip archive directory information available 
+# instead of being automatically corrected to use the new correct zip archive 
+# directory information. 
+if '__pypy__' in sys.builtin_module_names: 
+    _replace_zip_directory_cache_data = \ 
+        _remove_and_clear_zip_directory_cache_data 
+else: 
+
+    def _replace_zip_directory_cache_data(normalized_path): 
+        def replace_cached_zip_archive_directory_data(path, old_entry): 
+            # N.B. In theory, we could load the zip directory information just 
+            # once for all updated path spellings, and then copy it locally and 
+            # update its contained path strings to contain the correct 
+            # spelling, but that seems like a way too invasive move (this cache 
+            # structure is not officially documented anywhere and could in 
+            # theory change with new Python releases) for no significant 
+            # benefit. 
+            old_entry.clear() 
+            zipimport.zipimporter(path) 
+            old_entry.update(zipimport._zip_directory_cache[path]) 
+            return old_entry 
+ 
+        _update_zipimporter_cache( 
+            normalized_path, zipimport._zip_directory_cache, 
+            updater=replace_cached_zip_archive_directory_data) 
+ 
+ 
+def is_python(text, filename='<string>'): 
+    "Is this string a valid Python script?" 
+    try: 
+        compile(text, filename, 'exec') 
+    except (SyntaxError, TypeError): 
+        return False 
+    else: 
+        return True 
+ 
+ 
+def is_sh(executable): 
+    """Determine if the specified executable is a .sh (contains a #! line)""" 
+    try: 
+        with io.open(executable, encoding='latin-1') as fp: 
+            magic = fp.read(2) 
+    except (OSError, IOError): 
+        return executable 
+    return magic == '#!' 
+ 
+ 
+def nt_quote_arg(arg): 
+    """Quote a command line argument according to Windows parsing rules""" 
+    return subprocess.list2cmdline([arg]) 
+ 
+ 
+def is_python_script(script_text, filename): 
+    """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc. 
+    """ 
+    if filename.endswith('.py') or filename.endswith('.pyw'): 
+        return True  # extension says it's Python 
+    if is_python(script_text, filename): 
+        return True  # it's syntactically valid Python 
+    if script_text.startswith('#!'): 
+        # It begins with a '#!' line, so check if 'python' is in it somewhere 
+        return 'python' in script_text.splitlines()[0].lower() 
+ 
+    return False  # Not any Python I can recognize 
+ 
+ 
+try: 
+    from os import chmod as _chmod 
+except ImportError: 
+    # Jython compatibility 
+    def _chmod(*args): 
+        pass 
+ 
+ 
+def chmod(path, mode): 
+    log.debug("changing mode of %s to %o", path, mode) 
+    try: 
+        _chmod(path, mode) 
+    except os.error as e: 
+        log.debug("chmod failed: %s", e) 
+ 
+ 
+class CommandSpec(list): 
+    """ 
+    A command spec for a #! header, specified as a list of arguments akin to 
+    those passed to Popen. 
+    """ 
+ 
+    options = [] 
+    split_args = dict() 
+ 
+    @classmethod 
+    def best(cls): 
+        """ 
+        Choose the best CommandSpec class based on environmental conditions. 
+        """ 
+        return cls 
+ 
+    @classmethod 
+    def _sys_executable(cls): 
+        _default = os.path.normpath(sys.executable) 
+        return os.environ.get('__PYVENV_LAUNCHER__', _default) 
+ 
+    @classmethod 
+    def from_param(cls, param): 
+        """ 
+        Construct a CommandSpec from a parameter to build_scripts, which may 
+        be None. 
+        """ 
+        if isinstance(param, cls): 
+            return param 
+        if isinstance(param, list): 
+            return cls(param) 
+        if param is None: 
+            return cls.from_environment() 
+        # otherwise, assume it's a string. 
+        return cls.from_string(param) 
+ 
+    @classmethod 
+    def from_environment(cls): 
+        return cls([cls._sys_executable()]) 
+ 
+    @classmethod 
+    def from_string(cls, string): 
+        """ 
+        Construct a command spec from a simple string representing a command 
+        line parseable by shlex.split. 
+        """ 
+        items = shlex.split(string, **cls.split_args) 
+        return cls(items) 
+ 
+    def install_options(self, script_text): 
+        self.options = shlex.split(self._extract_options(script_text)) 
+        cmdline = subprocess.list2cmdline(self) 
+        if not isascii(cmdline): 
+            self.options[:0] = ['-x'] 
+ 
+    @staticmethod 
+    def _extract_options(orig_script): 
+        """ 
+        Extract any options from the first line of the script. 
+        """ 
+        first = (orig_script + '\n').splitlines()[0] 
+        match = _first_line_re().match(first) 
+        options = match.group(1) or '' if match else '' 
+        return options.strip() 
+ 
+    def as_header(self): 
+        return self._render(self + list(self.options)) 
+ 
+    @staticmethod 
     def _strip_quotes(item):
         _QUOTES = '"\''
         for q in _QUOTES:
@@ -2046,301 +2046,301 @@ class CommandSpec(list):
         return item
 
     @staticmethod
-    def _render(items):
+    def _render(items): 
         cmdline = subprocess.list2cmdline(
             CommandSpec._strip_quotes(item.strip()) for item in items)
-        return '#!' + cmdline + '\n'
-
-
-# For pbr compat; will be removed in a future version.
-sys_executable = CommandSpec._sys_executable()
-
-
-class WindowsCommandSpec(CommandSpec):
-    split_args = dict(posix=False)
-
-
+        return '#!' + cmdline + '\n' 
+ 
+
+# For pbr compat; will be removed in a future version. 
+sys_executable = CommandSpec._sys_executable() 
+ 
+ 
+class WindowsCommandSpec(CommandSpec): 
+    split_args = dict(posix=False) 
+ 
+ 
 class ScriptWriter:
-    """
-    Encapsulates behavior around writing entry point scripts for console and
-    gui apps.
-    """
-
+    """ 
+    Encapsulates behavior around writing entry point scripts for console and 
+    gui apps. 
+    """ 
+ 
     template = textwrap.dedent(r"""
-        # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r
-        __requires__ = %(spec)r
+        # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r 
+        __requires__ = %(spec)r 
         import re
-        import sys
-        from pkg_resources import load_entry_point
-
-        if __name__ == '__main__':
+        import sys 
+        from pkg_resources import load_entry_point 
+ 
+        if __name__ == '__main__': 
             sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-            sys.exit(
-                load_entry_point(%(spec)r, %(group)r, %(name)r)()
-            )
-    """).lstrip()
-
-    command_spec_class = CommandSpec
-
-    @classmethod
-    def get_script_args(cls, dist, executable=None, wininst=False):
-        # for backward compatibility
+            sys.exit( 
+                load_entry_point(%(spec)r, %(group)r, %(name)r)() 
+            ) 
+    """).lstrip() 
+ 
+    command_spec_class = CommandSpec 
+ 
+    @classmethod 
+    def get_script_args(cls, dist, executable=None, wininst=False): 
+        # for backward compatibility 
         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)
-
-    @classmethod
-    def get_script_header(cls, script_text, executable=None, wininst=False):
-        # for backward compatibility
+        writer = (WindowsScriptWriter if wininst else ScriptWriter).best() 
+        header = cls.get_script_header("", executable, wininst) 
+        return writer.get_args(dist, header) 
+ 
+    @classmethod 
+    def get_script_header(cls, script_text, executable=None, wininst=False): 
+        # for backward compatibility 
         warnings.warn("Use get_header", EasyInstallDeprecationWarning, stacklevel=2)
-        if wininst:
-            executable = "python.exe"
+        if wininst: 
+            executable = "python.exe" 
         return cls.get_header(script_text, executable)
-
-    @classmethod
-    def get_args(cls, dist, header=None):
-        """
-        Yield write_script() argument tuples for a distribution's
-        console_scripts and gui_scripts entry points.
-        """
-        if header is None:
-            header = cls.get_header()
-        spec = str(dist.as_requirement())
-        for type_ in 'console', 'gui':
-            group = type_ + '_scripts'
-            for name, ep in dist.get_entry_map(group).items():
-                cls._ensure_safe_name(name)
-                script_text = cls.template % locals()
-                args = cls._get_script_args(type_, name, header, script_text)
-                for res in args:
-                    yield res
-
-    @staticmethod
-    def _ensure_safe_name(name):
-        """
-        Prevent paths in *_scripts entry point names.
-        """
-        has_path_sep = re.search(r'[\\/]', name)
-        if has_path_sep:
-            raise ValueError("Path separators not allowed in script names")
-
-    @classmethod
-    def get_writer(cls, force_windows):
-        # for backward compatibility
+ 
+    @classmethod 
+    def get_args(cls, dist, header=None): 
+        """ 
+        Yield write_script() argument tuples for a distribution's 
+        console_scripts and gui_scripts entry points. 
+        """ 
+        if header is None: 
+            header = cls.get_header() 
+        spec = str(dist.as_requirement()) 
+        for type_ in 'console', 'gui': 
+            group = type_ + '_scripts' 
+            for name, ep in dist.get_entry_map(group).items(): 
+                cls._ensure_safe_name(name) 
+                script_text = cls.template % locals() 
+                args = cls._get_script_args(type_, name, header, script_text) 
+                for res in args: 
+                    yield res 
+ 
+    @staticmethod 
+    def _ensure_safe_name(name): 
+        """ 
+        Prevent paths in *_scripts entry point names. 
+        """ 
+        has_path_sep = re.search(r'[\\/]', name) 
+        if has_path_sep: 
+            raise ValueError("Path separators not allowed in script names") 
+ 
+    @classmethod 
+    def get_writer(cls, force_windows): 
+        # for backward compatibility 
         warnings.warn("Use best", EasyInstallDeprecationWarning)
-        return WindowsScriptWriter.best() if force_windows else cls.best()
-
-    @classmethod
-    def best(cls):
-        """
-        Select the best ScriptWriter for this environment.
-        """
-        if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'):
-            return WindowsScriptWriter.best()
-        else:
-            return cls
-
-    @classmethod
-    def _get_script_args(cls, type_, name, header, script_text):
-        # Simply write the stub with no extension.
-        yield (name, header + script_text)
-
-    @classmethod
-    def get_header(cls, script_text="", executable=None):
-        """Create a #! line, getting options (if any) from script_text"""
-        cmd = cls.command_spec_class.best().from_param(executable)
-        cmd.install_options(script_text)
-        return cmd.as_header()
-
-
-class WindowsScriptWriter(ScriptWriter):
-    command_spec_class = WindowsCommandSpec
-
-    @classmethod
-    def get_writer(cls):
-        # for backward compatibility
+        return WindowsScriptWriter.best() if force_windows else cls.best() 
+ 
+    @classmethod 
+    def best(cls): 
+        """ 
+        Select the best ScriptWriter for this environment. 
+        """ 
+        if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'): 
+            return WindowsScriptWriter.best() 
+        else: 
+            return cls 
+ 
+    @classmethod 
+    def _get_script_args(cls, type_, name, header, script_text): 
+        # Simply write the stub with no extension. 
+        yield (name, header + script_text) 
+ 
+    @classmethod 
+    def get_header(cls, script_text="", executable=None): 
+        """Create a #! line, getting options (if any) from script_text""" 
+        cmd = cls.command_spec_class.best().from_param(executable) 
+        cmd.install_options(script_text) 
+        return cmd.as_header() 
+ 
+ 
+class WindowsScriptWriter(ScriptWriter): 
+    command_spec_class = WindowsCommandSpec 
+ 
+    @classmethod 
+    def get_writer(cls): 
+        # for backward compatibility 
         warnings.warn("Use best", EasyInstallDeprecationWarning)
-        return cls.best()
-
-    @classmethod
-    def best(cls):
-        """
-        Select the best ScriptWriter suitable for Windows
-        """
-        writer_lookup = dict(
-            executable=WindowsExecutableLauncherWriter,
-            natural=cls,
-        )
-        # for compatibility, use the executable launcher by default
-        launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable')
-        return writer_lookup[launcher]
-
-    @classmethod
-    def _get_script_args(cls, type_, name, header, script_text):
-        "For Windows, add a .py extension"
-        ext = dict(console='.pya', gui='.pyw')[type_]
-        if ext not in os.environ['PATHEXT'].lower().split(';'):
+        return cls.best() 
+ 
+    @classmethod 
+    def best(cls): 
+        """ 
+        Select the best ScriptWriter suitable for Windows 
+        """ 
+        writer_lookup = dict( 
+            executable=WindowsExecutableLauncherWriter, 
+            natural=cls, 
+        ) 
+        # for compatibility, use the executable launcher by default 
+        launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable') 
+        return writer_lookup[launcher] 
+ 
+    @classmethod 
+    def _get_script_args(cls, type_, name, header, script_text): 
+        "For Windows, add a .py extension" 
+        ext = dict(console='.pya', gui='.pyw')[type_] 
+        if ext not in os.environ['PATHEXT'].lower().split(';'): 
             msg = (
                 "{ext} not listed in PATHEXT; scripts will not be "
                 "recognized as executables."
             ).format(**locals())
             warnings.warn(msg, UserWarning)
-        old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe']
-        old.remove(ext)
-        header = cls._adjust_header(type_, header)
-        blockers = [name + x for x in old]
-        yield name + ext, header + script_text, 't', blockers
-
-    @classmethod
-    def _adjust_header(cls, type_, orig_header):
-        """
-        Make sure 'pythonw' is used for gui and and 'python' is used for
-        console (regardless of what sys.executable is).
-        """
-        pattern = 'pythonw.exe'
-        repl = 'python.exe'
-        if type_ == 'gui':
-            pattern, repl = repl, pattern
-        pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
-        new_header = pattern_ob.sub(string=orig_header, repl=repl)
-        return new_header if cls._use_header(new_header) else orig_header
-
-    @staticmethod
-    def _use_header(new_header):
-        """
-        Should _adjust_header use the replaced header?
-
-        On non-windows systems, always use. On
-        Windows systems, only use the replaced header if it resolves
-        to an executable on the system.
-        """
-        clean_header = new_header[2:-1].strip('"')
-        return sys.platform != 'win32' or find_executable(clean_header)
-
-
-class WindowsExecutableLauncherWriter(WindowsScriptWriter):
-    @classmethod
-    def _get_script_args(cls, type_, name, header, script_text):
-        """
-        For Windows, add a .py extension and an .exe launcher
-        """
-        if type_ == 'gui':
-            launcher_type = 'gui'
-            ext = '-script.pyw'
-            old = ['.pyw']
-        else:
-            launcher_type = 'cli'
-            ext = '-script.py'
-            old = ['.py', '.pyc', '.pyo']
-        hdr = cls._adjust_header(type_, header)
-        blockers = [name + x for x in old]
-        yield (name + ext, hdr + script_text, 't', blockers)
-        yield (
-            name + '.exe', get_win_launcher(launcher_type),
-            'b'  # write in binary mode
-        )
-        if not is_64bit():
-            # install a manifest for the launcher to prevent Windows
-            # from detecting it as an installer (which it will for
-            #  launchers like easy_install.exe). Consider only
-            #  adding a manifest for launchers detected as installers.
-            #  See Distribute #143 for details.
-            m_name = name + '.exe.manifest'
-            yield (m_name, load_launcher_manifest(name), 't')
-
-
-# for backward-compatibility
-get_script_args = ScriptWriter.get_script_args
-get_script_header = ScriptWriter.get_script_header
-
-
-def get_win_launcher(type):
-    """
-    Load the Windows launcher (executable) suitable for launching a script.
-
-    `type` should be either 'cli' or 'gui'
-
-    Returns the executable as a byte string.
-    """
-    launcher_fn = '%s.exe' % type
-    if is_64bit():
-        launcher_fn = launcher_fn.replace(".", "-64.")
-    else:
-        launcher_fn = launcher_fn.replace(".", "-32.")
-    return resource_string('setuptools', launcher_fn)
-
-
-def load_launcher_manifest(name):
-    manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml')
-    if six.PY2:
-        return manifest % vars()
-    else:
-        return manifest.decode('utf-8') % vars()
-
-
-def rmtree(path, ignore_errors=False, onerror=auto_chmod):
+        old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe'] 
+        old.remove(ext) 
+        header = cls._adjust_header(type_, header) 
+        blockers = [name + x for x in old] 
+        yield name + ext, header + script_text, 't', blockers 
+ 
+    @classmethod 
+    def _adjust_header(cls, type_, orig_header): 
+        """ 
+        Make sure 'pythonw' is used for gui and and 'python' is used for 
+        console (regardless of what sys.executable is). 
+        """ 
+        pattern = 'pythonw.exe' 
+        repl = 'python.exe' 
+        if type_ == 'gui': 
+            pattern, repl = repl, pattern 
+        pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE) 
+        new_header = pattern_ob.sub(string=orig_header, repl=repl) 
+        return new_header if cls._use_header(new_header) else orig_header 
+ 
+    @staticmethod 
+    def _use_header(new_header): 
+        """ 
+        Should _adjust_header use the replaced header? 
+ 
+        On non-windows systems, always use. On 
+        Windows systems, only use the replaced header if it resolves 
+        to an executable on the system. 
+        """ 
+        clean_header = new_header[2:-1].strip('"') 
+        return sys.platform != 'win32' or find_executable(clean_header) 
+ 
+ 
+class WindowsExecutableLauncherWriter(WindowsScriptWriter): 
+    @classmethod 
+    def _get_script_args(cls, type_, name, header, script_text): 
+        """ 
+        For Windows, add a .py extension and an .exe launcher 
+        """ 
+        if type_ == 'gui': 
+            launcher_type = 'gui' 
+            ext = '-script.pyw' 
+            old = ['.pyw'] 
+        else: 
+            launcher_type = 'cli' 
+            ext = '-script.py' 
+            old = ['.py', '.pyc', '.pyo'] 
+        hdr = cls._adjust_header(type_, header) 
+        blockers = [name + x for x in old] 
+        yield (name + ext, hdr + script_text, 't', blockers) 
+        yield ( 
+            name + '.exe', get_win_launcher(launcher_type), 
+            'b'  # write in binary mode 
+        ) 
+        if not is_64bit(): 
+            # install a manifest for the launcher to prevent Windows 
+            # from detecting it as an installer (which it will for 
+            #  launchers like easy_install.exe). Consider only 
+            #  adding a manifest for launchers detected as installers. 
+            #  See Distribute #143 for details. 
+            m_name = name + '.exe.manifest' 
+            yield (m_name, load_launcher_manifest(name), 't') 
+ 
+ 
+# for backward-compatibility 
+get_script_args = ScriptWriter.get_script_args 
+get_script_header = ScriptWriter.get_script_header 
+ 
+ 
+def get_win_launcher(type): 
+    """ 
+    Load the Windows launcher (executable) suitable for launching a script. 
+ 
+    `type` should be either 'cli' or 'gui' 
+ 
+    Returns the executable as a byte string. 
+    """ 
+    launcher_fn = '%s.exe' % type 
+    if is_64bit(): 
+        launcher_fn = launcher_fn.replace(".", "-64.") 
+    else: 
+        launcher_fn = launcher_fn.replace(".", "-32.") 
+    return resource_string('setuptools', launcher_fn) 
+ 
+ 
+def load_launcher_manifest(name): 
+    manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml') 
+    if six.PY2: 
+        return manifest % vars() 
+    else: 
+        return manifest.decode('utf-8') % vars() 
+ 
+ 
+def rmtree(path, ignore_errors=False, onerror=auto_chmod): 
     return shutil.rmtree(path, ignore_errors, onerror)
-
-
-def current_umask():
-    tmp = os.umask(0o022)
-    os.umask(tmp)
-    return tmp
-
-
-def bootstrap():
-    # This function is called when setuptools*.egg is run using /bin/sh
-    import setuptools
-
-    argv0 = os.path.dirname(setuptools.__path__[0])
-    sys.argv[0] = argv0
-    sys.argv.append(argv0)
-    main()
-
-
-def main(argv=None, **kw):
-    from setuptools import setup
-    from setuptools.dist import Distribution
-
-    class DistributionWithoutHelpCommands(Distribution):
-        common_usage = ""
-
-        def _show_help(self, *args, **kw):
-            with _patch_usage():
-                Distribution._show_help(self, *args, **kw)
-
-    if argv is None:
-        argv = sys.argv[1:]
-
-    with _patch_usage():
-        setup(
-            script_args=['-q', 'easy_install', '-v'] + argv,
-            script_name=sys.argv[0] or 'easy_install',
+ 
+ 
+def current_umask(): 
+    tmp = os.umask(0o022) 
+    os.umask(tmp) 
+    return tmp 
+ 
+ 
+def bootstrap(): 
+    # This function is called when setuptools*.egg is run using /bin/sh 
+    import setuptools 
+ 
+    argv0 = os.path.dirname(setuptools.__path__[0]) 
+    sys.argv[0] = argv0 
+    sys.argv.append(argv0) 
+    main() 
+ 
+ 
+def main(argv=None, **kw): 
+    from setuptools import setup 
+    from setuptools.dist import Distribution 
+ 
+    class DistributionWithoutHelpCommands(Distribution): 
+        common_usage = "" 
+ 
+        def _show_help(self, *args, **kw): 
+            with _patch_usage(): 
+                Distribution._show_help(self, *args, **kw) 
+ 
+    if argv is None: 
+        argv = sys.argv[1:] 
+ 
+    with _patch_usage(): 
+        setup( 
+            script_args=['-q', 'easy_install', '-v'] + argv, 
+            script_name=sys.argv[0] or 'easy_install', 
             distclass=DistributionWithoutHelpCommands,
             **kw
-        )
-
-
-@contextlib.contextmanager
-def _patch_usage():
-    import distutils.core
-    USAGE = textwrap.dedent("""
-        usage: %(script)s [options] requirement_or_url ...
-           or: %(script)s --help
-        """).lstrip()
-
-    def gen_usage(script_name):
-        return USAGE % dict(
-            script=os.path.basename(script_name),
-        )
-
-    saved = distutils.core.gen_usage
-    distutils.core.gen_usage = gen_usage
-    try:
-        yield
-    finally:
-        distutils.core.gen_usage = saved
+        ) 
+ 
+ 
+@contextlib.contextmanager 
+def _patch_usage(): 
+    import distutils.core 
+    USAGE = textwrap.dedent(""" 
+        usage: %(script)s [options] requirement_or_url ... 
+           or: %(script)s --help 
+        """).lstrip() 
+ 
+    def gen_usage(script_name): 
+        return USAGE % dict( 
+            script=os.path.basename(script_name), 
+        ) 
+ 
+    saved = distutils.core.gen_usage 
+    distutils.core.gen_usage = gen_usage 
+    try: 
+        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."""
diff --git a/contrib/python/setuptools/py2/setuptools/command/egg_info.py b/contrib/python/setuptools/py2/setuptools/command/egg_info.py
index a5c5a2fc19..9760018aed 100644
--- a/contrib/python/setuptools/py2/setuptools/command/egg_info.py
+++ b/contrib/python/setuptools/py2/setuptools/command/egg_info.py
@@ -1,38 +1,38 @@
-"""setuptools.command.egg_info
-
-Create a distribution's .egg-info directory and contents"""
-
-from distutils.filelist import FileList as _FileList
+"""setuptools.command.egg_info 
+ 
+Create a distribution's .egg-info directory and contents""" 
+ 
+from distutils.filelist import FileList as _FileList 
 from distutils.errors import DistutilsInternalError
-from distutils.util import convert_path
-from distutils import log
-import distutils.errors
-import distutils.filelist
-import os
-import re
-import sys
-import io
-import warnings
-import time
+from distutils.util import convert_path 
+from distutils import log 
+import distutils.errors 
+import distutils.filelist 
+import os 
+import re 
+import sys 
+import io 
+import warnings 
+import time 
 import collections
-
+ 
 from setuptools.extern import six
 from setuptools.extern.six.moves import map
-
-from setuptools import Command
-from setuptools.command.sdist import sdist
-from setuptools.command.sdist import walk_revctrl
-from setuptools.command.setopt import edit_config
-from setuptools.command import bdist_egg
-from pkg_resources import (
-    parse_requirements, safe_name, parse_version,
-    safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename)
-import setuptools.unicode_utils as unicode_utils
+ 
+from setuptools import Command 
+from setuptools.command.sdist import sdist 
+from setuptools.command.sdist import walk_revctrl 
+from setuptools.command.setopt import edit_config 
+from setuptools.command import bdist_egg 
+from pkg_resources import ( 
+    parse_requirements, safe_name, parse_version, 
+    safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename) 
+import setuptools.unicode_utils as unicode_utils 
 from setuptools.glob import glob
-
+ 
 from setuptools.extern import packaging
 from setuptools import SetuptoolsDeprecationWarning
-
+ 
 def translate_pattern(glob):
     """
     Translate a file path glob like '*.txt' in to a regular expression.
@@ -41,7 +41,7 @@ def translate_pattern(glob):
     directories.
     """
     pat = ''
-
+ 
     # This will split on '/' within [character classes]. This is deliberate.
     chunks = glob.split(os.path.sep)
 
@@ -143,28 +143,28 @@ class InfoCommon:
 
 
 class egg_info(InfoCommon, Command):
-    description = "create a distribution's .egg-info directory"
-
-    user_options = [
-        ('egg-base=', 'e', "directory containing .egg-info directories"
-                           " (default: top of the source tree)"),
-        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
-        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
-        ('no-date', 'D', "Don't include date stamp [default]"),
-    ]
-
+    description = "create a distribution's .egg-info directory" 
+ 
+    user_options = [ 
+        ('egg-base=', 'e', "directory containing .egg-info directories" 
+                           " (default: top of the source tree)"), 
+        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"), 
+        ('tag-build=', 'b', "Specify explicit tag to add to version number"), 
+        ('no-date', 'D', "Don't include date stamp [default]"), 
+    ] 
+ 
     boolean_options = ['tag-date']
     negative_opt = {
         'no-date': 'tag-date',
     }
-
-    def initialize_options(self):
+ 
+    def initialize_options(self): 
         self.egg_base = None
-        self.egg_name = None
+        self.egg_name = None 
         self.egg_info = None
-        self.egg_version = None
-        self.broken_egg_info = False
-
+        self.egg_version = None 
+        self.broken_egg_info = False 
+ 
     ####################################
     # allow the 'tag_svn_revision' to be detected and
     # set, supporting sdists built on older Setuptools.
@@ -177,7 +177,7 @@ class egg_info(InfoCommon, Command):
         pass
     ####################################
 
-    def save_version_info(self, filename):
+    def save_version_info(self, filename): 
         """
         Materialize the value of date into the
         build tag. Install build keys in a deterministic order
@@ -189,139 +189,139 @@ class egg_info(InfoCommon, Command):
         egg_info['tag_build'] = self.tags()
         egg_info['tag_date'] = 0
         edit_config(filename, dict(egg_info=egg_info))
-
-    def finalize_options(self):
+ 
+    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
-        self.egg_version = self.tagged_version()
-        parsed_version = parse_version(self.egg_version)
-
-        try:
-            is_version = isinstance(parsed_version, packaging.version.Version)
-            spec = (
-                "%s==%s" if is_version else "%s===%s"
-            )
-            list(
-                parse_requirements(spec % (self.egg_name, self.egg_version))
-            )
-        except ValueError:
-            raise distutils.errors.DistutilsOptionError(
-                "Invalid distribution name or version syntax: %s-%s" %
-                (self.egg_name, self.egg_version)
-            )
-
-        if self.egg_base is None:
-            dirs = self.distribution.package_dir
-            self.egg_base = (dirs or {}).get('', os.curdir)
-
-        self.ensure_dirname('egg_base')
-        self.egg_info = to_filename(self.egg_name) + '.egg-info'
-        if self.egg_base != os.curdir:
-            self.egg_info = os.path.join(self.egg_base, self.egg_info)
-        if '-' in self.egg_name:
-            self.check_broken_egg_info()
-
-        # Set package version for the benefit of dumber commands
-        # (e.g. sdist, bdist_wininst, etc.)
-        #
-        self.distribution.metadata.version = self.egg_version
-
-        # If we bootstrapped around the lack of a PKG-INFO, as might be the
-        # case in a fresh checkout, make sure that any special tags get added
-        # to the version info
-        #
-        pd = self.distribution._patched_dist
-        if pd is not None and pd.key == self.egg_name.lower():
-            pd._version = self.egg_version
-            pd._parsed_version = parse_version(self.egg_version)
-            self.distribution._patched_dist = None
-
-    def write_or_delete_file(self, what, filename, data, force=False):
-        """Write `data` to `filename` or delete if empty
-
-        If `data` is non-empty, this routine is the same as ``write_file()``.
-        If `data` is empty but not ``None``, this is the same as calling
-        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op
-        unless `filename` exists, in which case a warning is issued about the
-        orphaned file (if `force` is false), or deleted (if `force` is true).
-        """
-        if data:
-            self.write_file(what, filename, data)
-        elif os.path.exists(filename):
-            if data is None and not force:
-                log.warn(
-                    "%s not set in setup(), but %s exists", what, filename
-                )
-                return
-            else:
-                self.delete_file(filename)
-
-    def write_file(self, what, filename, data):
-        """Write `data` to `filename` (if not a dry run) after announcing it
-
-        `what` is used in a log message to identify what is being written
-        to the file.
-        """
-        log.info("writing %s to %s", what, filename)
+        self.egg_version = self.tagged_version() 
+        parsed_version = parse_version(self.egg_version) 
+ 
+        try: 
+            is_version = isinstance(parsed_version, packaging.version.Version) 
+            spec = ( 
+                "%s==%s" if is_version else "%s===%s" 
+            ) 
+            list( 
+                parse_requirements(spec % (self.egg_name, self.egg_version)) 
+            ) 
+        except ValueError: 
+            raise distutils.errors.DistutilsOptionError( 
+                "Invalid distribution name or version syntax: %s-%s" % 
+                (self.egg_name, self.egg_version) 
+            ) 
+ 
+        if self.egg_base is None: 
+            dirs = self.distribution.package_dir 
+            self.egg_base = (dirs or {}).get('', os.curdir) 
+ 
+        self.ensure_dirname('egg_base') 
+        self.egg_info = to_filename(self.egg_name) + '.egg-info' 
+        if self.egg_base != os.curdir: 
+            self.egg_info = os.path.join(self.egg_base, self.egg_info) 
+        if '-' in self.egg_name: 
+            self.check_broken_egg_info() 
+ 
+        # Set package version for the benefit of dumber commands 
+        # (e.g. sdist, bdist_wininst, etc.) 
+        # 
+        self.distribution.metadata.version = self.egg_version 
+ 
+        # If we bootstrapped around the lack of a PKG-INFO, as might be the 
+        # case in a fresh checkout, make sure that any special tags get added 
+        # to the version info 
+        # 
+        pd = self.distribution._patched_dist 
+        if pd is not None and pd.key == self.egg_name.lower(): 
+            pd._version = self.egg_version 
+            pd._parsed_version = parse_version(self.egg_version) 
+            self.distribution._patched_dist = None 
+ 
+    def write_or_delete_file(self, what, filename, data, force=False): 
+        """Write `data` to `filename` or delete if empty 
+ 
+        If `data` is non-empty, this routine is the same as ``write_file()``. 
+        If `data` is empty but not ``None``, this is the same as calling 
+        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op 
+        unless `filename` exists, in which case a warning is issued about the 
+        orphaned file (if `force` is false), or deleted (if `force` is true). 
+        """ 
+        if data: 
+            self.write_file(what, filename, data) 
+        elif os.path.exists(filename): 
+            if data is None and not force: 
+                log.warn( 
+                    "%s not set in setup(), but %s exists", what, filename 
+                ) 
+                return 
+            else: 
+                self.delete_file(filename) 
+ 
+    def write_file(self, what, filename, data): 
+        """Write `data` to `filename` (if not a dry run) after announcing it 
+ 
+        `what` is used in a log message to identify what is being written 
+        to the file. 
+        """ 
+        log.info("writing %s to %s", what, filename) 
         if not six.PY2:
-            data = data.encode("utf-8")
-        if not self.dry_run:
-            f = open(filename, 'wb')
-            f.write(data)
-            f.close()
-
-    def delete_file(self, filename):
-        """Delete `filename` (if not a dry run) after announcing it"""
-        log.info("deleting %s", filename)
-        if not self.dry_run:
-            os.unlink(filename)
-
-    def run(self):
-        self.mkpath(self.egg_info)
+            data = data.encode("utf-8") 
+        if not self.dry_run: 
+            f = open(filename, 'wb') 
+            f.write(data) 
+            f.close() 
+ 
+    def delete_file(self, filename): 
+        """Delete `filename` (if not a dry run) after announcing it""" 
+        log.info("deleting %s", filename) 
+        if not self.dry_run: 
+            os.unlink(filename) 
+ 
+    def run(self): 
+        self.mkpath(self.egg_info) 
         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)
-            writer = ep.resolve()
-            writer(self, ep.name, os.path.join(self.egg_info, ep.name))
-
-        # Get rid of native_libs.txt if it was put there by older bdist_egg
-        nl = os.path.join(self.egg_info, "native_libs.txt")
-        if os.path.exists(nl):
-            self.delete_file(nl)
-
-        self.find_sources()
-
-    def find_sources(self):
-        """Generate SOURCES.txt manifest file"""
-        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
-        mm = manifest_maker(self.distribution)
-        mm.manifest = manifest_filename
-        mm.run()
-        self.filelist = mm.filelist
-
-    def check_broken_egg_info(self):
-        bei = self.egg_name + '.egg-info'
-        if self.egg_base != os.curdir:
-            bei = os.path.join(self.egg_base, bei)
-        if os.path.exists(bei):
-            log.warn(
-                "-" * 78 + '\n'
-                "Note: Your current .egg-info directory has a '-' in its name;"
-                '\nthis will not work correctly with "setup.py develop".\n\n'
-                'Please rename %s to %s to correct this problem.\n' + '-' * 78,
-                bei, self.egg_info
-            )
-            self.broken_egg_info = self.egg_info
-            self.egg_info = bei  # make it work for now
-
-
-class FileList(_FileList):
+        installer = self.distribution.fetch_build_egg 
+        for ep in iter_entry_points('egg_info.writers'): 
+            ep.require(installer=installer) 
+            writer = ep.resolve() 
+            writer(self, ep.name, os.path.join(self.egg_info, ep.name)) 
+ 
+        # Get rid of native_libs.txt if it was put there by older bdist_egg 
+        nl = os.path.join(self.egg_info, "native_libs.txt") 
+        if os.path.exists(nl): 
+            self.delete_file(nl) 
+ 
+        self.find_sources() 
+ 
+    def find_sources(self): 
+        """Generate SOURCES.txt manifest file""" 
+        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt") 
+        mm = manifest_maker(self.distribution) 
+        mm.manifest = manifest_filename 
+        mm.run() 
+        self.filelist = mm.filelist 
+ 
+    def check_broken_egg_info(self): 
+        bei = self.egg_name + '.egg-info' 
+        if self.egg_base != os.curdir: 
+            bei = os.path.join(self.egg_base, bei) 
+        if os.path.exists(bei): 
+            log.warn( 
+                "-" * 78 + '\n' 
+                "Note: Your current .egg-info directory has a '-' in its name;" 
+                '\nthis will not work correctly with "setup.py develop".\n\n' 
+                'Please rename %s to %s to correct this problem.\n' + '-' * 78, 
+                bei, self.egg_info 
+            ) 
+            self.broken_egg_info = self.egg_info 
+            self.egg_info = bei  # make it work for now 
+ 
+ 
+class FileList(_FileList): 
     # Implementations of the various MANIFEST.in commands
-
+ 
     def process_template_line(self, line):
         # Parse the line: split it up, make sure the right number of words
         # is there, and return the relevant words.  'action' is always
@@ -470,95 +470,95 @@ class FileList(_FileList):
         match = translate_pattern(os.path.join('**', pattern))
         return self._remove_files(match.match)
 
-    def append(self, item):
-        if item.endswith('\r'):  # Fix older sdists built on Windows
-            item = item[:-1]
-        path = convert_path(item)
-
-        if self._safe_path(path):
-            self.files.append(path)
-
-    def extend(self, paths):
-        self.files.extend(filter(self._safe_path, paths))
-
-    def _repair(self):
-        """
-        Replace self.files with only safe paths
-
-        Because some owners of FileList manipulate the underlying
-        ``files`` attribute directly, this method must be called to
-        repair those paths.
-        """
-        self.files = list(filter(self._safe_path, self.files))
-
-    def _safe_path(self, path):
-        enc_warn = "'%s' not %s encodable -- skipping"
-
-        # To avoid accidental trans-codings errors, first to unicode
-        u_path = unicode_utils.filesys_decode(path)
-        if u_path is None:
-            log.warn("'%s' in unexpected encoding -- skipping" % path)
-            return False
-
-        # Must ensure utf-8 encodability
-        utf8_path = unicode_utils.try_encode(u_path, "utf-8")
-        if utf8_path is None:
-            log.warn(enc_warn, path, 'utf-8')
-            return False
-
-        try:
-            # accept is either way checks out
-            if os.path.exists(u_path) or os.path.exists(utf8_path):
-                return True
-        # this will catch any encode errors decoding u_path
-        except UnicodeEncodeError:
-            log.warn(enc_warn, path, sys.getfilesystemencoding())
-
-
-class manifest_maker(sdist):
-    template = "MANIFEST.in"
-
-    def initialize_options(self):
-        self.use_defaults = 1
-        self.prune = 1
-        self.manifest_only = 1
-        self.force_manifest = 1
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        self.filelist = FileList()
-        if not os.path.exists(self.manifest):
-            self.write_manifest()  # it must exist so it'll get in the list
-        self.add_defaults()
-        if os.path.exists(self.template):
-            self.read_template()
-        self.prune_file_list()
-        self.filelist.sort()
-        self.filelist.remove_duplicates()
-        self.write_manifest()
-
-    def _manifest_normalize(self, path):
-        path = unicode_utils.filesys_decode(path)
-        return path.replace(os.sep, '/')
-
-    def write_manifest(self):
-        """
-        Write the file list in 'self.filelist' to the manifest file
-        named by 'self.manifest'.
-        """
-        self.filelist._repair()
-
-        # Now _repairs should encodability, but not unicode
-        files = [self._manifest_normalize(f) for f in self.filelist.files]
-        msg = "writing manifest file '%s'" % self.manifest
-        self.execute(write_file, (self.manifest, files), msg)
-
+    def append(self, item): 
+        if item.endswith('\r'):  # Fix older sdists built on Windows 
+            item = item[:-1] 
+        path = convert_path(item) 
+ 
+        if self._safe_path(path): 
+            self.files.append(path) 
+ 
+    def extend(self, paths): 
+        self.files.extend(filter(self._safe_path, paths)) 
+ 
+    def _repair(self): 
+        """ 
+        Replace self.files with only safe paths 
+ 
+        Because some owners of FileList manipulate the underlying 
+        ``files`` attribute directly, this method must be called to 
+        repair those paths. 
+        """ 
+        self.files = list(filter(self._safe_path, self.files)) 
+ 
+    def _safe_path(self, path): 
+        enc_warn = "'%s' not %s encodable -- skipping" 
+ 
+        # To avoid accidental trans-codings errors, first to unicode 
+        u_path = unicode_utils.filesys_decode(path) 
+        if u_path is None: 
+            log.warn("'%s' in unexpected encoding -- skipping" % path) 
+            return False 
+ 
+        # Must ensure utf-8 encodability 
+        utf8_path = unicode_utils.try_encode(u_path, "utf-8") 
+        if utf8_path is None: 
+            log.warn(enc_warn, path, 'utf-8') 
+            return False 
+ 
+        try: 
+            # accept is either way checks out 
+            if os.path.exists(u_path) or os.path.exists(utf8_path): 
+                return True 
+        # this will catch any encode errors decoding u_path 
+        except UnicodeEncodeError: 
+            log.warn(enc_warn, path, sys.getfilesystemencoding()) 
+ 
+ 
+class manifest_maker(sdist): 
+    template = "MANIFEST.in" 
+ 
+    def initialize_options(self): 
+        self.use_defaults = 1 
+        self.prune = 1 
+        self.manifest_only = 1 
+        self.force_manifest = 1 
+ 
+    def finalize_options(self): 
+        pass 
+ 
+    def run(self): 
+        self.filelist = FileList() 
+        if not os.path.exists(self.manifest): 
+            self.write_manifest()  # it must exist so it'll get in the list 
+        self.add_defaults() 
+        if os.path.exists(self.template): 
+            self.read_template() 
+        self.prune_file_list() 
+        self.filelist.sort() 
+        self.filelist.remove_duplicates() 
+        self.write_manifest() 
+ 
+    def _manifest_normalize(self, path): 
+        path = unicode_utils.filesys_decode(path) 
+        return path.replace(os.sep, '/') 
+ 
+    def write_manifest(self): 
+        """ 
+        Write the file list in 'self.filelist' to the manifest file 
+        named by 'self.manifest'. 
+        """ 
+        self.filelist._repair() 
+ 
+        # Now _repairs should encodability, but not unicode 
+        files = [self._manifest_normalize(f) for f in self.filelist.files] 
+        msg = "writing manifest file '%s'" % self.manifest 
+        self.execute(write_file, (self.manifest, files), msg) 
+ 
     def warn(self, msg):
         if not self._should_suppress_warning(msg):
-            sdist.warn(self, msg)
-
+            sdist.warn(self, msg) 
+ 
     @staticmethod
     def _should_suppress_warning(msg):
         """
@@ -566,151 +566,151 @@ class manifest_maker(sdist):
         """
         return re.match(r"standard file .*not found", msg)
 
-    def add_defaults(self):
-        sdist.add_defaults(self)
+    def add_defaults(self): 
+        sdist.add_defaults(self) 
         self.check_license()
-        self.filelist.append(self.template)
-        self.filelist.append(self.manifest)
-        rcfiles = list(walk_revctrl())
-        if rcfiles:
-            self.filelist.extend(rcfiles)
-        elif os.path.exists(self.manifest):
-            self.read_manifest()
+        self.filelist.append(self.template) 
+        self.filelist.append(self.manifest) 
+        rcfiles = list(walk_revctrl()) 
+        if rcfiles: 
+            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")
 
-        ei_cmd = self.get_finalized_command('egg_info')
+        ei_cmd = self.get_finalized_command('egg_info') 
         self.filelist.graft(ei_cmd.egg_info)
-
-    def prune_file_list(self):
-        build = self.get_finalized_command('build')
-        base_dir = self.distribution.get_fullname()
+ 
+    def prune_file_list(self): 
+        build = self.get_finalized_command('build') 
+        base_dir = self.distribution.get_fullname() 
         self.filelist.prune(build.build_base)
         self.filelist.prune(base_dir)
-        sep = re.escape(os.sep)
-        self.filelist.exclude_pattern(r'(^|' + sep + r')(RCS|CVS|\.svn)' + sep,
-                                      is_regex=1)
-
-
-def write_file(filename, contents):
-    """Create a file with the specified name and write 'contents' (a
-    sequence of strings without line terminators) to it.
-    """
-    contents = "\n".join(contents)
-
-    # assuming the contents has been vetted for utf-8 encoding
-    contents = contents.encode("utf-8")
-
-    with open(filename, "wb") as f:  # always write POSIX-style manifest
-        f.write(contents)
-
-
-def write_pkg_info(cmd, basename, filename):
-    log.info("writing %s", filename)
-    if not cmd.dry_run:
-        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
-            metadata.write_pkg_info(cmd.egg_info)
-        finally:
-            metadata.name, metadata.version = oldname, oldver
-
-        safe = getattr(cmd.distribution, 'zip_safe', None)
-
-        bdist_egg.write_safety_flag(cmd.egg_info, safe)
-
-
-def warn_depends_obsolete(cmd, basename, filename):
-    if os.path.exists(filename):
-        log.warn(
-            "WARNING: 'depends.txt' is not used by setuptools 0.6!\n"
-            "Use the install_requires/extras_require setup() args instead."
-        )
-
-
-def _write_requirements(stream, reqs):
-    lines = yield_lines(reqs or ())
-    append_cr = lambda line: line + '\n'
-    lines = map(append_cr, lines)
-    stream.writelines(lines)
-
-
-def write_requirements(cmd, basename, filename):
-    dist = cmd.distribution
-    data = six.StringIO()
-    _write_requirements(data, dist.install_requires)
-    extras_require = dist.extras_require or {}
-    for extra in sorted(extras_require):
-        data.write('\n[{extra}]\n'.format(**vars()))
-        _write_requirements(data, extras_require[extra])
-    cmd.write_or_delete_file("requirements", filename, data.getvalue())
-
-
-def write_setup_requirements(cmd, basename, filename):
+        sep = re.escape(os.sep) 
+        self.filelist.exclude_pattern(r'(^|' + sep + r')(RCS|CVS|\.svn)' + sep, 
+                                      is_regex=1) 
+ 
+ 
+def write_file(filename, contents): 
+    """Create a file with the specified name and write 'contents' (a 
+    sequence of strings without line terminators) to it. 
+    """ 
+    contents = "\n".join(contents) 
+ 
+    # assuming the contents has been vetted for utf-8 encoding 
+    contents = contents.encode("utf-8") 
+ 
+    with open(filename, "wb") as f:  # always write POSIX-style manifest 
+        f.write(contents) 
+ 
+ 
+def write_pkg_info(cmd, basename, filename): 
+    log.info("writing %s", filename) 
+    if not cmd.dry_run: 
+        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 
+            metadata.write_pkg_info(cmd.egg_info) 
+        finally: 
+            metadata.name, metadata.version = oldname, oldver 
+ 
+        safe = getattr(cmd.distribution, 'zip_safe', None) 
+ 
+        bdist_egg.write_safety_flag(cmd.egg_info, safe) 
+ 
+ 
+def warn_depends_obsolete(cmd, basename, filename): 
+    if os.path.exists(filename): 
+        log.warn( 
+            "WARNING: 'depends.txt' is not used by setuptools 0.6!\n" 
+            "Use the install_requires/extras_require setup() args instead." 
+        ) 
+ 
+ 
+def _write_requirements(stream, reqs): 
+    lines = yield_lines(reqs or ()) 
+    append_cr = lambda line: line + '\n' 
+    lines = map(append_cr, lines) 
+    stream.writelines(lines) 
+ 
+ 
+def write_requirements(cmd, basename, filename): 
+    dist = cmd.distribution 
+    data = six.StringIO() 
+    _write_requirements(data, dist.install_requires) 
+    extras_require = dist.extras_require or {} 
+    for extra in sorted(extras_require): 
+        data.write('\n[{extra}]\n'.format(**vars())) 
+        _write_requirements(data, extras_require[extra]) 
+    cmd.write_or_delete_file("requirements", filename, data.getvalue()) 
+ 
+ 
+def write_setup_requirements(cmd, basename, filename): 
     data = io.StringIO()
-    _write_requirements(data, cmd.distribution.setup_requires)
-    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())
-
-
-def write_toplevel_names(cmd, basename, filename):
-    pkgs = dict.fromkeys(
-        [
-            k.split('.', 1)[0]
-            for k in cmd.distribution.iter_distribution_names()
-        ]
-    )
-    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')
-
-
-def overwrite_arg(cmd, basename, filename):
-    write_arg(cmd, basename, filename, True)
-
-
-def write_arg(cmd, basename, filename, force=False):
-    argname = os.path.splitext(basename)[0]
-    value = getattr(cmd.distribution, argname, None)
-    if value is not None:
-        value = '\n'.join(value) + '\n'
-    cmd.write_or_delete_file(argname, filename, value, force)
-
-
-def write_entries(cmd, basename, filename):
-    ep = cmd.distribution.entry_points
-
-    if isinstance(ep, six.string_types) or ep is None:
-        data = ep
-    elif ep is not None:
-        data = []
-        for section, contents in sorted(ep.items()):
-            if not isinstance(contents, six.string_types):
-                contents = EntryPoint.parse_group(section, contents)
-                contents = '\n'.join(sorted(map(str, contents.values())))
-            data.append('[%s]\n%s\n\n' % (section, contents))
-        data = ''.join(data)
-
-    cmd.write_or_delete_file('entry points', filename, data, True)
-
-
-def get_pkg_info_revision():
-    """
-    Get a -r### off of PKG-INFO Version in case this is an sdist of
-    a subversion revision.
-    """
+    _write_requirements(data, cmd.distribution.setup_requires) 
+    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue()) 
+ 
+ 
+def write_toplevel_names(cmd, basename, filename): 
+    pkgs = dict.fromkeys( 
+        [ 
+            k.split('.', 1)[0] 
+            for k in cmd.distribution.iter_distribution_names() 
+        ] 
+    ) 
+    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n') 
+ 
+ 
+def overwrite_arg(cmd, basename, filename): 
+    write_arg(cmd, basename, filename, True) 
+ 
+ 
+def write_arg(cmd, basename, filename, force=False): 
+    argname = os.path.splitext(basename)[0] 
+    value = getattr(cmd.distribution, argname, None) 
+    if value is not None: 
+        value = '\n'.join(value) + '\n' 
+    cmd.write_or_delete_file(argname, filename, value, force) 
+ 
+ 
+def write_entries(cmd, basename, filename): 
+    ep = cmd.distribution.entry_points 
+ 
+    if isinstance(ep, six.string_types) or ep is None: 
+        data = ep 
+    elif ep is not None: 
+        data = [] 
+        for section, contents in sorted(ep.items()): 
+            if not isinstance(contents, six.string_types): 
+                contents = EntryPoint.parse_group(section, contents) 
+                contents = '\n'.join(sorted(map(str, contents.values()))) 
+            data.append('[%s]\n%s\n\n' % (section, contents)) 
+        data = ''.join(data) 
+ 
+    cmd.write_or_delete_file('entry points', filename, data, True) 
+ 
+ 
+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)
-    if os.path.exists('PKG-INFO'):
-        with io.open('PKG-INFO') as f:
-            for line in f:
-                match = re.match(r"Version:.*-r(\d+)\s*$", line)
-                if match:
-                    return int(match.group(1))
-    return 0
+    if os.path.exists('PKG-INFO'): 
+        with io.open('PKG-INFO') as f: 
+            for line in f: 
+                match = re.match(r"Version:.*-r(\d+)\s*$", line) 
+                if match: 
+                    return int(match.group(1)) 
+    return 0 
 
 
 class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning):
diff --git a/contrib/python/setuptools/py2/setuptools/command/install.py b/contrib/python/setuptools/py2/setuptools/command/install.py
index 72b9a3e424..236862a647 100644
--- a/contrib/python/setuptools/py2/setuptools/command/install.py
+++ b/contrib/python/setuptools/py2/setuptools/command/install.py
@@ -1,125 +1,125 @@
-from distutils.errors import DistutilsArgError
-import inspect
-import glob
-import warnings
-import platform
-import distutils.command.install as orig
-
-import setuptools
-
-# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for
+from distutils.errors import DistutilsArgError 
+import inspect 
+import glob 
+import warnings 
+import platform 
+import distutils.command.install as orig 
+ 
+import setuptools 
+ 
+# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for 
 # now. See https://github.com/pypa/setuptools/issues/199/
-_install = orig.install
-
-
-class install(orig.install):
-    """Use easy_install to install the package, w/dependencies"""
-
-    user_options = orig.install.user_options + [
-        ('old-and-unmanageable', None, "Try not to use this!"),
-        ('single-version-externally-managed', None,
-         "used by system package builders to create 'flat' eggs"),
-    ]
-    boolean_options = orig.install.boolean_options + [
-        'old-and-unmanageable', 'single-version-externally-managed',
-    ]
-    new_commands = [
-        ('install_egg_info', lambda self: True),
-        ('install_scripts', lambda self: True),
-    ]
-    _nc = dict(new_commands)
-
-    def initialize_options(self):
-        orig.install.initialize_options(self)
-        self.old_and_unmanageable = None
-        self.single_version_externally_managed = None
-
-    def finalize_options(self):
-        orig.install.finalize_options(self)
-        if self.root:
-            self.single_version_externally_managed = True
-        elif self.single_version_externally_managed:
-            if not self.root and not self.record:
-                raise DistutilsArgError(
-                    "You must specify --record or --root when building system"
-                    " packages"
-                )
-
-    def handle_extra_path(self):
-        if self.root or self.single_version_externally_managed:
-            # explicit backward-compatibility mode, allow extra_path to work
-            return orig.install.handle_extra_path(self)
-
-        # Ignore extra_path when installing an egg (or being run by another
-        # command without --root or --single-version-externally-managed
-        self.path_file = None
-        self.extra_dirs = ''
-
-    def run(self):
-        # Explicit request for old-style install?  Just do it
-        if self.old_and_unmanageable or self.single_version_externally_managed:
-            return orig.install.run(self)
-
-        if not self._called_from_setup(inspect.currentframe()):
-            # Run in backward-compatibility mode to support bdist_* commands.
-            orig.install.run(self)
-        else:
-            self.do_egg_install()
-
-    @staticmethod
-    def _called_from_setup(run_frame):
-        """
-        Attempt to detect whether run() was called from setup() or by another
-        command.  If called by setup(), the parent caller will be the
-        'run_command' method in 'distutils.dist', and *its* caller will be
-        the 'run_commands' method.  If called any other way, the
-        immediate caller *might* be 'run_command', but it won't have been
-        called by 'run_commands'. Return True in that case or if a call stack
-        is unavailable. Return False otherwise.
-        """
-        if run_frame is None:
-            msg = "Call stack not available. bdist_* commands may fail."
-            warnings.warn(msg)
-            if platform.python_implementation() == 'IronPython':
-                msg = "For best results, pass -X:Frames to enable call stack."
-                warnings.warn(msg)
-            return True
-        res = inspect.getouterframes(run_frame)[2]
-        caller, = res[:1]
-        info = inspect.getframeinfo(caller)
-        caller_module = caller.f_globals.get('__name__', '')
-        return (
-            caller_module == 'distutils.dist'
-            and info.function == 'run_commands'
-        )
-
-    def do_egg_install(self):
-
-        easy_install = self.distribution.get_command_class('easy_install')
-
-        cmd = easy_install(
-            self.distribution, args="x", root=self.root, record=self.record,
-        )
-        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd
-        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed
-
-        # pick up setup-dir .egg files only: no .egg-info
-        cmd.package_index.scan(glob.glob('*.egg'))
-
-        self.run_command('bdist_egg')
-        args = [self.distribution.get_command_obj('bdist_egg').egg_output]
-
-        if setuptools.bootstrap_install_from:
-            # Bootstrap self-installation of setuptools
-            args.insert(0, setuptools.bootstrap_install_from)
-
-        cmd.args = args
+_install = orig.install 
+ 
+ 
+class install(orig.install): 
+    """Use easy_install to install the package, w/dependencies""" 
+ 
+    user_options = orig.install.user_options + [ 
+        ('old-and-unmanageable', None, "Try not to use this!"), 
+        ('single-version-externally-managed', None, 
+         "used by system package builders to create 'flat' eggs"), 
+    ] 
+    boolean_options = orig.install.boolean_options + [ 
+        'old-and-unmanageable', 'single-version-externally-managed', 
+    ] 
+    new_commands = [ 
+        ('install_egg_info', lambda self: True), 
+        ('install_scripts', lambda self: True), 
+    ] 
+    _nc = dict(new_commands) 
+ 
+    def initialize_options(self): 
+        orig.install.initialize_options(self) 
+        self.old_and_unmanageable = None 
+        self.single_version_externally_managed = None 
+ 
+    def finalize_options(self): 
+        orig.install.finalize_options(self) 
+        if self.root: 
+            self.single_version_externally_managed = True 
+        elif self.single_version_externally_managed: 
+            if not self.root and not self.record: 
+                raise DistutilsArgError( 
+                    "You must specify --record or --root when building system" 
+                    " packages" 
+                ) 
+ 
+    def handle_extra_path(self): 
+        if self.root or self.single_version_externally_managed: 
+            # explicit backward-compatibility mode, allow extra_path to work 
+            return orig.install.handle_extra_path(self) 
+ 
+        # Ignore extra_path when installing an egg (or being run by another 
+        # command without --root or --single-version-externally-managed 
+        self.path_file = None 
+        self.extra_dirs = '' 
+ 
+    def run(self): 
+        # Explicit request for old-style install?  Just do it 
+        if self.old_and_unmanageable or self.single_version_externally_managed: 
+            return orig.install.run(self) 
+ 
+        if not self._called_from_setup(inspect.currentframe()): 
+            # Run in backward-compatibility mode to support bdist_* commands. 
+            orig.install.run(self) 
+        else: 
+            self.do_egg_install() 
+ 
+    @staticmethod 
+    def _called_from_setup(run_frame): 
+        """ 
+        Attempt to detect whether run() was called from setup() or by another 
+        command.  If called by setup(), the parent caller will be the 
+        'run_command' method in 'distutils.dist', and *its* caller will be 
+        the 'run_commands' method.  If called any other way, the 
+        immediate caller *might* be 'run_command', but it won't have been 
+        called by 'run_commands'. Return True in that case or if a call stack 
+        is unavailable. Return False otherwise. 
+        """ 
+        if run_frame is None: 
+            msg = "Call stack not available. bdist_* commands may fail." 
+            warnings.warn(msg) 
+            if platform.python_implementation() == 'IronPython': 
+                msg = "For best results, pass -X:Frames to enable call stack." 
+                warnings.warn(msg) 
+            return True 
+        res = inspect.getouterframes(run_frame)[2] 
+        caller, = res[:1] 
+        info = inspect.getframeinfo(caller) 
+        caller_module = caller.f_globals.get('__name__', '') 
+        return ( 
+            caller_module == 'distutils.dist' 
+            and info.function == 'run_commands' 
+        ) 
+ 
+    def do_egg_install(self): 
+ 
+        easy_install = self.distribution.get_command_class('easy_install') 
+ 
+        cmd = easy_install( 
+            self.distribution, args="x", root=self.root, record=self.record, 
+        ) 
+        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd 
+        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed 
+ 
+        # pick up setup-dir .egg files only: no .egg-info 
+        cmd.package_index.scan(glob.glob('*.egg')) 
+ 
+        self.run_command('bdist_egg') 
+        args = [self.distribution.get_command_obj('bdist_egg').egg_output] 
+ 
+        if setuptools.bootstrap_install_from: 
+            # Bootstrap self-installation of setuptools 
+            args.insert(0, setuptools.bootstrap_install_from) 
+ 
+        cmd.args = args 
         cmd.run(show_deprecation=False)
-        setuptools.bootstrap_install_from = None
-
-
-# XXX Python 3.1 doesn't see _nc if this is inside the class
-install.sub_commands = (
-    [cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc] +
-    install.new_commands
-)
+        setuptools.bootstrap_install_from = None 
+ 
+ 
+# XXX Python 3.1 doesn't see _nc if this is inside the class 
+install.sub_commands = ( 
+    [cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc] + 
+    install.new_commands 
+) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/install_egg_info.py b/contrib/python/setuptools/py2/setuptools/command/install_egg_info.py
index edc4718b68..10bdb832a9 100644
--- a/contrib/python/setuptools/py2/setuptools/command/install_egg_info.py
+++ b/contrib/python/setuptools/py2/setuptools/command/install_egg_info.py
@@ -1,62 +1,62 @@
-from distutils import log, dir_util
-import os
-
-from setuptools import Command
+from distutils import log, dir_util 
+import os 
+ 
+from setuptools import Command 
 from setuptools import namespaces
-from setuptools.archive_util import unpack_archive
-import pkg_resources
-
-
+from setuptools.archive_util import unpack_archive 
+import pkg_resources 
+ 
+ 
 class install_egg_info(namespaces.Installer, Command):
-    """Install an .egg-info directory for the package"""
-
-    description = "Install an .egg-info directory for the package"
-
-    user_options = [
-        ('install-dir=', 'd', "directory to install to"),
-    ]
-
-    def initialize_options(self):
-        self.install_dir = None
-
-    def finalize_options(self):
-        self.set_undefined_options('install_lib',
-                                   ('install_dir', 'install_dir'))
-        ei_cmd = self.get_finalized_command("egg_info")
-        basename = pkg_resources.Distribution(
-            None, None, ei_cmd.egg_name, ei_cmd.egg_version
-        ).egg_name() + '.egg-info'
-        self.source = ei_cmd.egg_info
-        self.target = os.path.join(self.install_dir, basename)
+    """Install an .egg-info directory for the package""" 
+ 
+    description = "Install an .egg-info directory for the package" 
+ 
+    user_options = [ 
+        ('install-dir=', 'd', "directory to install to"), 
+    ] 
+ 
+    def initialize_options(self): 
+        self.install_dir = None 
+ 
+    def finalize_options(self): 
+        self.set_undefined_options('install_lib', 
+                                   ('install_dir', 'install_dir')) 
+        ei_cmd = self.get_finalized_command("egg_info") 
+        basename = pkg_resources.Distribution( 
+            None, None, ei_cmd.egg_name, ei_cmd.egg_version 
+        ).egg_name() + '.egg-info' 
+        self.source = ei_cmd.egg_info 
+        self.target = os.path.join(self.install_dir, basename) 
         self.outputs = []
-
-    def run(self):
-        self.run_command('egg_info')
-        if os.path.isdir(self.target) and not os.path.islink(self.target):
-            dir_util.remove_tree(self.target, dry_run=self.dry_run)
-        elif os.path.exists(self.target):
-            self.execute(os.unlink, (self.target,), "Removing " + self.target)
-        if not self.dry_run:
-            pkg_resources.ensure_directory(self.target)
-        self.execute(
-            self.copytree, (), "Copying %s to %s" % (self.source, self.target)
-        )
-        self.install_namespaces()
-
-    def get_outputs(self):
-        return self.outputs
-
-    def copytree(self):
-        # Copy the .egg-info tree to site-packages
-        def skimmer(src, dst):
-            # filter out source-control directories; note that 'src' is always
-            # a '/'-separated path, regardless of platform.  'dst' is a
-            # platform-specific path.
-            for skip in '.svn/', 'CVS/':
-                if src.startswith(skip) or '/' + skip in src:
-                    return None
-            self.outputs.append(dst)
-            log.debug("Copying %s to %s", src, dst)
-            return dst
-
-        unpack_archive(self.source, self.target, skimmer)
+ 
+    def run(self): 
+        self.run_command('egg_info') 
+        if os.path.isdir(self.target) and not os.path.islink(self.target): 
+            dir_util.remove_tree(self.target, dry_run=self.dry_run) 
+        elif os.path.exists(self.target): 
+            self.execute(os.unlink, (self.target,), "Removing " + self.target) 
+        if not self.dry_run: 
+            pkg_resources.ensure_directory(self.target) 
+        self.execute( 
+            self.copytree, (), "Copying %s to %s" % (self.source, self.target) 
+        ) 
+        self.install_namespaces() 
+ 
+    def get_outputs(self): 
+        return self.outputs 
+ 
+    def copytree(self): 
+        # Copy the .egg-info tree to site-packages 
+        def skimmer(src, dst): 
+            # filter out source-control directories; note that 'src' is always 
+            # a '/'-separated path, regardless of platform.  'dst' is a 
+            # platform-specific path. 
+            for skip in '.svn/', 'CVS/': 
+                if src.startswith(skip) or '/' + skip in src: 
+                    return None 
+            self.outputs.append(dst) 
+            log.debug("Copying %s to %s", src, dst) 
+            return dst 
+ 
+        unpack_archive(self.source, self.target, skimmer) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/install_lib.py b/contrib/python/setuptools/py2/setuptools/command/install_lib.py
index 07d6593309..96f37ab050 100644
--- a/contrib/python/setuptools/py2/setuptools/command/install_lib.py
+++ b/contrib/python/setuptools/py2/setuptools/command/install_lib.py
@@ -1,121 +1,121 @@
-import os
+import os 
 import sys
-from itertools import product, starmap
-import distutils.command.install_lib as orig
-
-
-class install_lib(orig.install_lib):
-    """Don't add compiled flags to filenames of non-Python files"""
-
-    def run(self):
-        self.build()
-        outfiles = self.install()
-        if outfiles is not None:
-            # always compile, in case we have any extension stubs to deal with
-            self.byte_compile(outfiles)
-
-    def get_exclusions(self):
-        """
-        Return a collections.Sized collections.Container of paths to be
-        excluded for single_version_externally_managed installations.
-        """
-        all_packages = (
-            pkg
-            for ns_pkg in self._get_SVEM_NSPs()
-            for pkg in self._all_packages(ns_pkg)
-        )
-
-        excl_specs = product(all_packages, self._gen_exclusion_paths())
-        return set(starmap(self._exclude_pkg_path, excl_specs))
-
-    def _exclude_pkg_path(self, pkg, exclusion_path):
-        """
-        Given a package name and exclusion path within that package,
-        compute the full exclusion path.
-        """
-        parts = pkg.split('.') + [exclusion_path]
-        return os.path.join(self.install_dir, *parts)
-
-    @staticmethod
-    def _all_packages(pkg_name):
-        """
-        >>> list(install_lib._all_packages('foo.bar.baz'))
-        ['foo.bar.baz', 'foo.bar', 'foo']
-        """
-        while pkg_name:
-            yield pkg_name
-            pkg_name, sep, child = pkg_name.rpartition('.')
-
-    def _get_SVEM_NSPs(self):
-        """
-        Get namespace packages (list) but only for
-        single_version_externally_managed installations and empty otherwise.
-        """
-        # TODO: is it necessary to short-circuit here? i.e. what's the cost
-        # if get_finalized_command is called even when namespace_packages is
-        # False?
-        if not self.distribution.namespace_packages:
-            return []
-
-        install_cmd = self.get_finalized_command('install')
-        svem = install_cmd.single_version_externally_managed
-
-        return self.distribution.namespace_packages if svem else []
-
-    @staticmethod
-    def _gen_exclusion_paths():
-        """
-        Generate file paths to be excluded for namespace packages (bytecode
-        cache files).
-        """
-        # always exclude the package module itself
-        yield '__init__.py'
-
-        yield '__init__.pyc'
-        yield '__init__.pyo'
-
+from itertools import product, starmap 
+import distutils.command.install_lib as orig 
+ 
+
+class install_lib(orig.install_lib): 
+    """Don't add compiled flags to filenames of non-Python files""" 
+ 
+    def run(self): 
+        self.build() 
+        outfiles = self.install() 
+        if outfiles is not None: 
+            # always compile, in case we have any extension stubs to deal with 
+            self.byte_compile(outfiles) 
+ 
+    def get_exclusions(self): 
+        """ 
+        Return a collections.Sized collections.Container of paths to be 
+        excluded for single_version_externally_managed installations. 
+        """ 
+        all_packages = ( 
+            pkg 
+            for ns_pkg in self._get_SVEM_NSPs() 
+            for pkg in self._all_packages(ns_pkg) 
+        ) 
+ 
+        excl_specs = product(all_packages, self._gen_exclusion_paths()) 
+        return set(starmap(self._exclude_pkg_path, excl_specs)) 
+ 
+    def _exclude_pkg_path(self, pkg, exclusion_path): 
+        """ 
+        Given a package name and exclusion path within that package, 
+        compute the full exclusion path. 
+        """ 
+        parts = pkg.split('.') + [exclusion_path] 
+        return os.path.join(self.install_dir, *parts) 
+ 
+    @staticmethod 
+    def _all_packages(pkg_name): 
+        """ 
+        >>> list(install_lib._all_packages('foo.bar.baz')) 
+        ['foo.bar.baz', 'foo.bar', 'foo'] 
+        """ 
+        while pkg_name: 
+            yield pkg_name 
+            pkg_name, sep, child = pkg_name.rpartition('.') 
+ 
+    def _get_SVEM_NSPs(self): 
+        """ 
+        Get namespace packages (list) but only for 
+        single_version_externally_managed installations and empty otherwise. 
+        """ 
+        # TODO: is it necessary to short-circuit here? i.e. what's the cost 
+        # if get_finalized_command is called even when namespace_packages is 
+        # False? 
+        if not self.distribution.namespace_packages: 
+            return [] 
+ 
+        install_cmd = self.get_finalized_command('install') 
+        svem = install_cmd.single_version_externally_managed 
+ 
+        return self.distribution.namespace_packages if svem else [] 
+ 
+    @staticmethod 
+    def _gen_exclusion_paths(): 
+        """ 
+        Generate file paths to be excluded for namespace packages (bytecode 
+        cache files). 
+        """ 
+        # always exclude the package module itself 
+        yield '__init__.py' 
+ 
+        yield '__init__.pyc' 
+        yield '__init__.pyo' 
+ 
         if not hasattr(sys, 'implementation'):
-            return
-
+            return 
+ 
         base = os.path.join('__pycache__', '__init__.' + sys.implementation.cache_tag)
-        yield base + '.pyc'
-        yield base + '.pyo'
-        yield base + '.opt-1.pyc'
-        yield base + '.opt-2.pyc'
-
-    def copy_tree(
-            self, infile, outfile,
-            preserve_mode=1, preserve_times=1, preserve_symlinks=0, level=1
-    ):
-        assert preserve_mode and preserve_times and not preserve_symlinks
-        exclude = self.get_exclusions()
-
-        if not exclude:
-            return orig.install_lib.copy_tree(self, infile, outfile)
-
-        # Exclude namespace package __init__.py* files from the output
-
-        from setuptools.archive_util import unpack_directory
-        from distutils import log
-
-        outfiles = []
-
-        def pf(src, dst):
-            if dst in exclude:
-                log.warn("Skipping installation of %s (namespace package)",
-                         dst)
-                return False
-
-            log.info("copying %s -> %s", src, os.path.dirname(dst))
-            outfiles.append(dst)
-            return dst
-
-        unpack_directory(infile, outfile, pf)
-        return outfiles
-
-    def get_outputs(self):
-        outputs = orig.install_lib.get_outputs(self)
-        exclude = self.get_exclusions()
-        if exclude:
-            return [f for f in outputs if f not in exclude]
-        return outputs
+        yield base + '.pyc' 
+        yield base + '.pyo' 
+        yield base + '.opt-1.pyc' 
+        yield base + '.opt-2.pyc' 
+ 
+    def copy_tree( 
+            self, infile, outfile, 
+            preserve_mode=1, preserve_times=1, preserve_symlinks=0, level=1 
+    ): 
+        assert preserve_mode and preserve_times and not preserve_symlinks 
+        exclude = self.get_exclusions() 
+ 
+        if not exclude: 
+            return orig.install_lib.copy_tree(self, infile, outfile) 
+ 
+        # Exclude namespace package __init__.py* files from the output 
+ 
+        from setuptools.archive_util import unpack_directory 
+        from distutils import log 
+ 
+        outfiles = [] 
+ 
+        def pf(src, dst): 
+            if dst in exclude: 
+                log.warn("Skipping installation of %s (namespace package)", 
+                         dst) 
+                return False 
+ 
+            log.info("copying %s -> %s", src, os.path.dirname(dst)) 
+            outfiles.append(dst) 
+            return dst 
+ 
+        unpack_directory(infile, outfile, pf) 
+        return outfiles 
+ 
+    def get_outputs(self): 
+        outputs = orig.install_lib.get_outputs(self) 
+        exclude = self.get_exclusions() 
+        if exclude: 
+            return [f for f in outputs if f not in exclude] 
+        return outputs 
diff --git a/contrib/python/setuptools/py2/setuptools/command/install_scripts.py b/contrib/python/setuptools/py2/setuptools/command/install_scripts.py
index 16234273a2..4902f2c621 100644
--- a/contrib/python/setuptools/py2/setuptools/command/install_scripts.py
+++ b/contrib/python/setuptools/py2/setuptools/command/install_scripts.py
@@ -1,65 +1,65 @@
-from distutils import log
-import distutils.command.install_scripts as orig
-import os
+from distutils import log 
+import distutils.command.install_scripts as orig 
+import os 
 import sys
-
-from pkg_resources import Distribution, PathMetadata, ensure_directory
-
-
-class install_scripts(orig.install_scripts):
-    """Do normal script install, plus any egg_info wrapper scripts"""
-
-    def initialize_options(self):
-        orig.install_scripts.initialize_options(self)
-        self.no_ep = False
-
-    def run(self):
-        import setuptools.command.easy_install as ei
-
-        self.run_command("egg_info")
-        if self.distribution.scripts:
-            orig.install_scripts.run(self)  # run first to set up self.outfiles
-        else:
-            self.outfiles = []
-        if self.no_ep:
-            # don't install entry point scripts into .egg file!
-            return
-
-        ei_cmd = self.get_finalized_command("egg_info")
-        dist = Distribution(
-            ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
-            ei_cmd.egg_name, ei_cmd.egg_version,
-        )
-        bs_cmd = self.get_finalized_command('build_scripts')
-        exec_param = getattr(bs_cmd, 'executable', None)
-        bw_cmd = self.get_finalized_command("bdist_wininst")
-        is_wininst = getattr(bw_cmd, '_is_running', False)
-        writer = ei.ScriptWriter
-        if is_wininst:
-            exec_param = "python.exe"
-            writer = ei.WindowsScriptWriter
+ 
+from pkg_resources import Distribution, PathMetadata, ensure_directory 
+ 
+ 
+class install_scripts(orig.install_scripts): 
+    """Do normal script install, plus any egg_info wrapper scripts""" 
+ 
+    def initialize_options(self): 
+        orig.install_scripts.initialize_options(self) 
+        self.no_ep = False 
+ 
+    def run(self): 
+        import setuptools.command.easy_install as ei 
+ 
+        self.run_command("egg_info") 
+        if self.distribution.scripts: 
+            orig.install_scripts.run(self)  # run first to set up self.outfiles 
+        else: 
+            self.outfiles = [] 
+        if self.no_ep: 
+            # don't install entry point scripts into .egg file! 
+            return 
+ 
+        ei_cmd = self.get_finalized_command("egg_info") 
+        dist = Distribution( 
+            ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info), 
+            ei_cmd.egg_name, ei_cmd.egg_version, 
+        ) 
+        bs_cmd = self.get_finalized_command('build_scripts') 
+        exec_param = getattr(bs_cmd, 'executable', None) 
+        bw_cmd = self.get_finalized_command("bdist_wininst") 
+        is_wininst = getattr(bw_cmd, '_is_running', False) 
+        writer = ei.ScriptWriter 
+        if is_wininst: 
+            exec_param = "python.exe" 
+            writer = ei.WindowsScriptWriter 
         if exec_param == sys.executable:
             # In case the path to the Python executable contains a space, wrap
             # it so it's not split up.
             exec_param = [exec_param]
-        # resolve the writer to the environment
-        writer = writer.best()
-        cmd = writer.command_spec_class.best().from_param(exec_param)
-        for args in writer.get_args(dist, cmd.as_header()):
-            self.write_script(*args)
-
-    def write_script(self, script_name, contents, mode="t", *ignored):
-        """Write an executable file to the scripts directory"""
-        from setuptools.command.easy_install import chmod, current_umask
-
-        log.info("Installing %s script to %s", script_name, self.install_dir)
-        target = os.path.join(self.install_dir, script_name)
-        self.outfiles.append(target)
-
-        mask = current_umask()
-        if not self.dry_run:
-            ensure_directory(target)
-            f = open(target, "w" + mode)
-            f.write(contents)
-            f.close()
-            chmod(target, 0o777 - mask)
+        # resolve the writer to the environment 
+        writer = writer.best() 
+        cmd = writer.command_spec_class.best().from_param(exec_param) 
+        for args in writer.get_args(dist, cmd.as_header()): 
+            self.write_script(*args) 
+ 
+    def write_script(self, script_name, contents, mode="t", *ignored): 
+        """Write an executable file to the scripts directory""" 
+        from setuptools.command.easy_install import chmod, current_umask 
+ 
+        log.info("Installing %s script to %s", script_name, self.install_dir) 
+        target = os.path.join(self.install_dir, script_name) 
+        self.outfiles.append(target) 
+ 
+        mask = current_umask() 
+        if not self.dry_run: 
+            ensure_directory(target) 
+            f = open(target, "w" + mode) 
+            f.write(contents) 
+            f.close() 
+            chmod(target, 0o777 - mask) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/register.py b/contrib/python/setuptools/py2/setuptools/command/register.py
index b8266b9a60..dbe5e619f7 100644
--- a/contrib/python/setuptools/py2/setuptools/command/register.py
+++ b/contrib/python/setuptools/py2/setuptools/command/register.py
@@ -1,13 +1,13 @@
 from distutils import log
-import distutils.command.register as orig
-
+import distutils.command.register as orig 
+ 
 from setuptools.errors import RemovedCommandError
+ 
 
-
-class register(orig.register):
+class register(orig.register): 
     """Formerly used to register packages on PyPI."""
-
-    def run(self):
+ 
+    def run(self): 
         msg = (
             "The register command has been removed, use twine to upload "
             + "instead (https://pypi.org/p/twine)"
diff --git a/contrib/python/setuptools/py2/setuptools/command/rotate.py b/contrib/python/setuptools/py2/setuptools/command/rotate.py
index b89353f529..3e873a97df 100644
--- a/contrib/python/setuptools/py2/setuptools/command/rotate.py
+++ b/contrib/python/setuptools/py2/setuptools/command/rotate.py
@@ -1,65 +1,65 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import os
+from distutils.util import convert_path 
+from distutils import log 
+from distutils.errors import DistutilsOptionError 
+import os 
 import shutil
-
+ 
 from setuptools.extern import six
-
-from setuptools import Command
-
-
-class rotate(Command):
-    """Delete older distributions"""
-
-    description = "delete older distributions, keeping N newest files"
-    user_options = [
-        ('match=', 'm', "patterns to match (required)"),
-        ('dist-dir=', 'd', "directory where the distributions are"),
-        ('keep=', 'k', "number of matching distributions to keep"),
-    ]
-
-    boolean_options = []
-
-    def initialize_options(self):
-        self.match = None
-        self.dist_dir = None
-        self.keep = None
-
-    def finalize_options(self):
-        if self.match is None:
-            raise DistutilsOptionError(
-                "Must specify one or more (comma-separated) match patterns "
-                "(e.g. '.zip' or '.egg')"
-            )
-        if self.keep is None:
-            raise DistutilsOptionError("Must specify number of files to keep")
-        try:
-            self.keep = int(self.keep)
-        except ValueError:
-            raise DistutilsOptionError("--keep must be an integer")
-        if isinstance(self.match, six.string_types):
-            self.match = [
-                convert_path(p.strip()) for p in self.match.split(',')
-            ]
-        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
-
-    def run(self):
-        self.run_command("egg_info")
-        from glob import glob
-
-        for pattern in self.match:
-            pattern = self.distribution.get_name() + '*' + pattern
-            files = glob(os.path.join(self.dist_dir, pattern))
-            files = [(os.path.getmtime(f), f) for f in files]
-            files.sort()
-            files.reverse()
-
-            log.info("%d file(s) matching %s", len(files), pattern)
-            files = files[self.keep:]
-            for (t, f) in files:
-                log.info("Deleting %s", f)
-                if not self.dry_run:
+ 
+from setuptools import Command 
+ 
+ 
+class rotate(Command): 
+    """Delete older distributions""" 
+ 
+    description = "delete older distributions, keeping N newest files" 
+    user_options = [ 
+        ('match=', 'm', "patterns to match (required)"), 
+        ('dist-dir=', 'd', "directory where the distributions are"), 
+        ('keep=', 'k', "number of matching distributions to keep"), 
+    ] 
+ 
+    boolean_options = [] 
+ 
+    def initialize_options(self): 
+        self.match = None 
+        self.dist_dir = None 
+        self.keep = None 
+ 
+    def finalize_options(self): 
+        if self.match is None: 
+            raise DistutilsOptionError( 
+                "Must specify one or more (comma-separated) match patterns " 
+                "(e.g. '.zip' or '.egg')" 
+            ) 
+        if self.keep is None: 
+            raise DistutilsOptionError("Must specify number of files to keep") 
+        try: 
+            self.keep = int(self.keep) 
+        except ValueError: 
+            raise DistutilsOptionError("--keep must be an integer") 
+        if isinstance(self.match, six.string_types): 
+            self.match = [ 
+                convert_path(p.strip()) for p in self.match.split(',') 
+            ] 
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir')) 
+ 
+    def run(self): 
+        self.run_command("egg_info") 
+        from glob import glob 
+ 
+        for pattern in self.match: 
+            pattern = self.distribution.get_name() + '*' + pattern 
+            files = glob(os.path.join(self.dist_dir, pattern)) 
+            files = [(os.path.getmtime(f), f) for f in files] 
+            files.sort() 
+            files.reverse() 
+ 
+            log.info("%d file(s) matching %s", len(files), pattern) 
+            files = files[self.keep:] 
+            for (t, f) in files: 
+                log.info("Deleting %s", f) 
+                if not self.dry_run: 
                     if os.path.isdir(f):
                         shutil.rmtree(f)
                     else:
diff --git a/contrib/python/setuptools/py2/setuptools/command/saveopts.py b/contrib/python/setuptools/py2/setuptools/command/saveopts.py
index 611cec5528..3ce03df53c 100644
--- a/contrib/python/setuptools/py2/setuptools/command/saveopts.py
+++ b/contrib/python/setuptools/py2/setuptools/command/saveopts.py
@@ -1,22 +1,22 @@
-from setuptools.command.setopt import edit_config, option_base
-
-
-class saveopts(option_base):
-    """Save command-line options to a file"""
-
-    description = "save supplied options to setup.cfg or other config file"
-
-    def run(self):
-        dist = self.distribution
-        settings = {}
-
-        for cmd in dist.command_options:
-
-            if cmd == 'saveopts':
-                continue  # don't save our own options!
-
-            for opt, (src, val) in dist.get_option_dict(cmd).items():
-                if src == "command line":
-                    settings.setdefault(cmd, {})[opt] = val
-
-        edit_config(self.filename, settings, self.dry_run)
+from setuptools.command.setopt import edit_config, option_base 
+ 
+ 
+class saveopts(option_base): 
+    """Save command-line options to a file""" 
+ 
+    description = "save supplied options to setup.cfg or other config file" 
+ 
+    def run(self): 
+        dist = self.distribution 
+        settings = {} 
+ 
+        for cmd in dist.command_options: 
+ 
+            if cmd == 'saveopts': 
+                continue  # don't save our own options! 
+ 
+            for opt, (src, val) in dist.get_option_dict(cmd).items(): 
+                if src == "command line": 
+                    settings.setdefault(cmd, {})[opt] = val 
+ 
+        edit_config(self.filename, settings, self.dry_run) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/sdist.py b/contrib/python/setuptools/py2/setuptools/command/sdist.py
index 8c3438eaa6..6afdfa4e0b 100644
--- a/contrib/python/setuptools/py2/setuptools/command/sdist.py
+++ b/contrib/python/setuptools/py2/setuptools/command/sdist.py
@@ -1,64 +1,64 @@
-from distutils import log
-import distutils.command.sdist as orig
-import os
-import sys
-import io
+from distutils import log 
+import distutils.command.sdist as orig 
+import os 
+import sys 
+import io 
 import contextlib
-
+ 
 from setuptools.extern import six, ordered_set
-
+ 
 from .py36compat import sdist_add_defaults
-
-import pkg_resources
-
-_default_revctrl = list
-
-
-def walk_revctrl(dirname=''):
-    """Find all files under revision control"""
-    for ep in pkg_resources.iter_entry_points('setuptools.file_finders'):
-        for item in ep.load()(dirname):
-            yield item
-
-
+ 
+import pkg_resources 
+ 
+_default_revctrl = list 
+ 
+
+def walk_revctrl(dirname=''): 
+    """Find all files under revision control""" 
+    for ep in pkg_resources.iter_entry_points('setuptools.file_finders'): 
+        for item in ep.load()(dirname): 
+            yield item 
+ 
+ 
 class sdist(sdist_add_defaults, orig.sdist):
-    """Smart sdist that finds anything supported by revision control"""
-
-    user_options = [
-        ('formats=', None,
-         "formats for source distribution (comma-separated list)"),
-        ('keep-temp', 'k',
-         "keep the distribution tree around after creating " +
-         "archive file(s)"),
-        ('dist-dir=', 'd',
-         "directory to put the source distribution archive(s) in "
-         "[default: dist]"),
-    ]
-
-    negative_opt = {}
-
+    """Smart sdist that finds anything supported by revision control""" 
+ 
+    user_options = [ 
+        ('formats=', None, 
+         "formats for source distribution (comma-separated list)"), 
+        ('keep-temp', 'k', 
+         "keep the distribution tree around after creating " + 
+         "archive file(s)"), 
+        ('dist-dir=', 'd', 
+         "directory to put the source distribution archive(s) in " 
+         "[default: dist]"), 
+    ] 
+ 
+    negative_opt = {} 
+ 
     README_EXTENSIONS = ['', '.rst', '.txt', '.md']
     READMES = tuple('README{0}'.format(ext) for ext in README_EXTENSIONS)
 
-    def run(self):
-        self.run_command('egg_info')
-        ei_cmd = self.get_finalized_command('egg_info')
-        self.filelist = ei_cmd.filelist
-        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
-        self.check_readme()
-
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        self.make_distribution()
-
-        dist_files = getattr(self.distribution, 'dist_files', [])
-        for file in self.archive_files:
-            data = ('sdist', '', file)
-            if data not in dist_files:
-                dist_files.append(data)
-
+    def run(self): 
+        self.run_command('egg_info') 
+        ei_cmd = self.get_finalized_command('egg_info') 
+        self.filelist = ei_cmd.filelist 
+        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt')) 
+        self.check_readme() 
+ 
+        # Run sub commands 
+        for cmd_name in self.get_sub_commands(): 
+            self.run_command(cmd_name) 
+ 
+        self.make_distribution() 
+ 
+        dist_files = getattr(self.distribution, 'dist_files', []) 
+        for file in self.archive_files: 
+            data = ('sdist', '', file) 
+            if data not in dist_files: 
+                dist_files.append(data) 
+ 
     def initialize_options(self):
         orig.sdist.initialize_options(self)
 
@@ -98,29 +98,29 @@ class sdist(sdist_add_defaults, orig.sdist):
             if orig_val is not NoValue:
                 setattr(os, 'link', orig_val)
 
-    def __read_template_hack(self):
-        # This grody hack closes the template file (MANIFEST.in) if an
-        #  exception occurs during read_template.
-        # Doing so prevents an error when easy_install attempts to delete the
-        #  file.
-        try:
-            orig.sdist.read_template(self)
+    def __read_template_hack(self): 
+        # This grody hack closes the template file (MANIFEST.in) if an 
+        #  exception occurs during read_template. 
+        # Doing so prevents an error when easy_install attempts to delete the 
+        #  file. 
+        try: 
+            orig.sdist.read_template(self) 
         except Exception:
-            _, _, tb = sys.exc_info()
-            tb.tb_next.tb_frame.f_locals['template'].close()
-            raise
-
-    # Beginning with Python 2.7.2, 3.1.4, and 3.2.1, this leaky file handle
-    #  has been fixed, so only override the method if we're using an earlier
-    #  Python.
-    has_leaky_handle = (
-        sys.version_info < (2, 7, 2)
-        or (3, 0) <= sys.version_info < (3, 1, 4)
-        or (3, 2) <= sys.version_info < (3, 2, 1)
-    )
-    if has_leaky_handle:
-        read_template = __read_template_hack
-
+            _, _, tb = sys.exc_info() 
+            tb.tb_next.tb_frame.f_locals['template'].close() 
+            raise 
+ 
+    # Beginning with Python 2.7.2, 3.1.4, and 3.2.1, this leaky file handle 
+    #  has been fixed, so only override the method if we're using an earlier 
+    #  Python. 
+    has_leaky_handle = ( 
+        sys.version_info < (2, 7, 2) 
+        or (3, 0) <= sys.version_info < (3, 1, 4) 
+        or (3, 2) <= sys.version_info < (3, 2, 1) 
+    ) 
+    if has_leaky_handle: 
+        read_template = __read_template_hack 
+ 
     def _add_defaults_optional(self):
         if six.PY2:
             sdist_add_defaults._add_defaults_optional(self)
@@ -131,11 +131,11 @@ class sdist(sdist_add_defaults, orig.sdist):
 
     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())
+        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
@@ -164,61 +164,61 @@ class sdist(sdist_add_defaults, orig.sdist):
                 super()._add_defaults_data_files()
         except TypeError:
             log.warn("data_files contains unexpected objects")
-
-    def check_readme(self):
+ 
+    def check_readme(self): 
         for f in self.READMES:
-            if os.path.exists(f):
-                return
-        else:
-            self.warn(
-                "standard file not found: should have one of " +
+            if os.path.exists(f): 
+                return 
+        else: 
+            self.warn( 
+                "standard file not found: should have one of " + 
                 ', '.join(self.READMES)
-            )
-
-    def make_release_tree(self, base_dir, files):
-        orig.sdist.make_release_tree(self, base_dir, files)
-
-        # Save any egg_info command line options used to create this sdist
-        dest = os.path.join(base_dir, 'setup.cfg')
-        if hasattr(os, 'link') and os.path.exists(dest):
-            # unlink and re-copy, since it might be hard-linked, and
-            # we don't want to change the source version
-            os.unlink(dest)
-            self.copy_file('setup.cfg', dest)
-
-        self.get_finalized_command('egg_info').save_version_info(dest)
-
-    def _manifest_is_not_generated(self):
-        # check for special comment used in 2.7.1 and higher
-        if not os.path.isfile(self.manifest):
-            return False
-
-        with io.open(self.manifest, 'rb') as fp:
-            first_line = fp.readline()
-        return (first_line !=
-                '# file GENERATED by distutils, do NOT edit\n'.encode())
-
-    def read_manifest(self):
-        """Read the manifest file (named by 'self.manifest') and use it to
-        fill in 'self.filelist', the list of files to include in the source
-        distribution.
-        """
-        log.info("reading manifest file '%s'", self.manifest)
+            ) 
+ 
+    def make_release_tree(self, base_dir, files): 
+        orig.sdist.make_release_tree(self, base_dir, files) 
+ 
+        # Save any egg_info command line options used to create this sdist 
+        dest = os.path.join(base_dir, 'setup.cfg') 
+        if hasattr(os, 'link') and os.path.exists(dest): 
+            # unlink and re-copy, since it might be hard-linked, and 
+            # we don't want to change the source version 
+            os.unlink(dest) 
+            self.copy_file('setup.cfg', dest) 
+ 
+        self.get_finalized_command('egg_info').save_version_info(dest) 
+ 
+    def _manifest_is_not_generated(self): 
+        # check for special comment used in 2.7.1 and higher 
+        if not os.path.isfile(self.manifest): 
+            return False 
+ 
+        with io.open(self.manifest, 'rb') as fp: 
+            first_line = fp.readline() 
+        return (first_line != 
+                '# file GENERATED by distutils, do NOT edit\n'.encode()) 
+ 
+    def read_manifest(self): 
+        """Read the manifest file (named by 'self.manifest') and use it to 
+        fill in 'self.filelist', the list of files to include in the source 
+        distribution. 
+        """ 
+        log.info("reading manifest file '%s'", self.manifest) 
         manifest = open(self.manifest, 'rb')
-        for line in manifest:
-            # The manifest must contain UTF-8. See #303.
+        for line in manifest: 
+            # The manifest must contain UTF-8. See #303. 
             if not six.PY2:
-                try:
-                    line = line.decode('UTF-8')
-                except UnicodeDecodeError:
-                    log.warn("%r not UTF-8 decodable -- skipping" % line)
-                    continue
-            # ignore comments and blank lines
-            line = line.strip()
-            if line.startswith('#') or not line:
-                continue
-            self.filelist.append(line)
-        manifest.close()
+                try: 
+                    line = line.decode('UTF-8') 
+                except UnicodeDecodeError: 
+                    log.warn("%r not UTF-8 decodable -- skipping" % line) 
+                    continue 
+            # ignore comments and blank lines 
+            line = line.strip() 
+            if line.startswith('#') or not line: 
+                continue 
+            self.filelist.append(line) 
+        manifest.close() 
 
     def check_license(self):
         """Checks if license_file' or 'license_files' is configured and adds any
diff --git a/contrib/python/setuptools/py2/setuptools/command/setopt.py b/contrib/python/setuptools/py2/setuptools/command/setopt.py
index 7e57cc0262..9677a92797 100644
--- a/contrib/python/setuptools/py2/setuptools/command/setopt.py
+++ b/contrib/python/setuptools/py2/setuptools/command/setopt.py
@@ -1,149 +1,149 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import distutils
-import os
-
+from distutils.util import convert_path 
+from distutils import log 
+from distutils.errors import DistutilsOptionError 
+import distutils 
+import os 
+ 
 from setuptools.extern.six.moves import configparser
-
-from setuptools import Command
-
-__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
-
-
-def config_file(kind="local"):
-    """Get the filename of the distutils, local, global, or per-user config
-
-    `kind` must be one of "local", "global", or "user"
-    """
-    if kind == 'local':
-        return 'setup.cfg'
-    if kind == 'global':
-        return os.path.join(
-            os.path.dirname(distutils.__file__), 'distutils.cfg'
-        )
-    if kind == 'user':
-        dot = os.name == 'posix' and '.' or ''
-        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
-    raise ValueError(
-        "config_file() type must be 'local', 'global', or 'user'", kind
-    )
-
-
-def edit_config(filename, settings, dry_run=False):
-    """Edit a configuration file to include `settings`
-
-    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
-    command/section name.  A ``None`` value means to delete the entire section,
-    while a dictionary lists settings to be changed or deleted in that section.
-    A setting of ``None`` means to delete that setting.
-    """
-    log.debug("Reading configuration from %s", filename)
-    opts = configparser.RawConfigParser()
-    opts.read([filename])
-    for section, options in settings.items():
-        if options is None:
-            log.info("Deleting section [%s] from %s", section, filename)
-            opts.remove_section(section)
-        else:
-            if not opts.has_section(section):
-                log.debug("Adding new section [%s] to %s", section, filename)
-                opts.add_section(section)
-            for option, value in options.items():
-                if value is None:
-                    log.debug(
-                        "Deleting %s.%s from %s",
-                        section, option, filename
-                    )
-                    opts.remove_option(section, option)
-                    if not opts.options(section):
-                        log.info("Deleting empty [%s] section from %s",
-                                 section, filename)
-                        opts.remove_section(section)
-                else:
-                    log.debug(
-                        "Setting %s.%s to %r in %s",
-                        section, option, value, filename
-                    )
-                    opts.set(section, option, value)
-
-    log.info("Writing %s", filename)
-    if not dry_run:
-        with open(filename, 'w') as f:
-            opts.write(f)
-
-
-class option_base(Command):
-    """Abstract base class for commands that mess with config files"""
-
-    user_options = [
-        ('global-config', 'g',
-         "save options to the site-wide distutils.cfg file"),
-        ('user-config', 'u',
-         "save options to the current user's pydistutils.cfg file"),
-        ('filename=', 'f',
-         "configuration file to use (default=setup.cfg)"),
-    ]
-
-    boolean_options = [
-        'global-config', 'user-config',
-    ]
-
-    def initialize_options(self):
-        self.global_config = None
-        self.user_config = None
-        self.filename = None
-
-    def finalize_options(self):
-        filenames = []
-        if self.global_config:
-            filenames.append(config_file('global'))
-        if self.user_config:
-            filenames.append(config_file('user'))
-        if self.filename is not None:
-            filenames.append(self.filename)
-        if not filenames:
-            filenames.append(config_file('local'))
-        if len(filenames) > 1:
-            raise DistutilsOptionError(
-                "Must specify only one configuration file option",
-                filenames
-            )
-        self.filename, = filenames
-
-
-class setopt(option_base):
-    """Save command-line options to a file"""
-
-    description = "set an option in setup.cfg or another config file"
-
-    user_options = [
-        ('command=', 'c', 'command to set an option for'),
-        ('option=', 'o', 'option to set'),
-        ('set-value=', 's', 'value of the option'),
-        ('remove', 'r', 'remove (unset) the value'),
-    ] + option_base.user_options
-
-    boolean_options = option_base.boolean_options + ['remove']
-
-    def initialize_options(self):
-        option_base.initialize_options(self)
-        self.command = None
-        self.option = None
-        self.set_value = None
-        self.remove = None
-
-    def finalize_options(self):
-        option_base.finalize_options(self)
-        if self.command is None or self.option is None:
-            raise DistutilsOptionError("Must specify --command *and* --option")
-        if self.set_value is None and not self.remove:
-            raise DistutilsOptionError("Must specify --set-value or --remove")
-
-    def run(self):
-        edit_config(
-            self.filename, {
-                self.command: {self.option.replace('-', '_'): self.set_value}
-            },
-            self.dry_run
-        )
+ 
+from setuptools import Command 
+ 
+__all__ = ['config_file', 'edit_config', 'option_base', 'setopt'] 
+ 
+ 
+def config_file(kind="local"): 
+    """Get the filename of the distutils, local, global, or per-user config 
+ 
+    `kind` must be one of "local", "global", or "user" 
+    """ 
+    if kind == 'local': 
+        return 'setup.cfg' 
+    if kind == 'global': 
+        return os.path.join( 
+            os.path.dirname(distutils.__file__), 'distutils.cfg' 
+        ) 
+    if kind == 'user': 
+        dot = os.name == 'posix' and '.' or '' 
+        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot)) 
+    raise ValueError( 
+        "config_file() type must be 'local', 'global', or 'user'", kind 
+    ) 
+ 
+ 
+def edit_config(filename, settings, dry_run=False): 
+    """Edit a configuration file to include `settings` 
+ 
+    `settings` is a dictionary of dictionaries or ``None`` values, keyed by 
+    command/section name.  A ``None`` value means to delete the entire section, 
+    while a dictionary lists settings to be changed or deleted in that section. 
+    A setting of ``None`` means to delete that setting. 
+    """ 
+    log.debug("Reading configuration from %s", filename) 
+    opts = configparser.RawConfigParser() 
+    opts.read([filename]) 
+    for section, options in settings.items(): 
+        if options is None: 
+            log.info("Deleting section [%s] from %s", section, filename) 
+            opts.remove_section(section) 
+        else: 
+            if not opts.has_section(section): 
+                log.debug("Adding new section [%s] to %s", section, filename) 
+                opts.add_section(section) 
+            for option, value in options.items(): 
+                if value is None: 
+                    log.debug( 
+                        "Deleting %s.%s from %s", 
+                        section, option, filename 
+                    ) 
+                    opts.remove_option(section, option) 
+                    if not opts.options(section): 
+                        log.info("Deleting empty [%s] section from %s", 
+                                 section, filename) 
+                        opts.remove_section(section) 
+                else: 
+                    log.debug( 
+                        "Setting %s.%s to %r in %s", 
+                        section, option, value, filename 
+                    ) 
+                    opts.set(section, option, value) 
+ 
+    log.info("Writing %s", filename) 
+    if not dry_run: 
+        with open(filename, 'w') as f: 
+            opts.write(f) 
+ 
+ 
+class option_base(Command): 
+    """Abstract base class for commands that mess with config files""" 
+ 
+    user_options = [ 
+        ('global-config', 'g', 
+         "save options to the site-wide distutils.cfg file"), 
+        ('user-config', 'u', 
+         "save options to the current user's pydistutils.cfg file"), 
+        ('filename=', 'f', 
+         "configuration file to use (default=setup.cfg)"), 
+    ] 
+ 
+    boolean_options = [ 
+        'global-config', 'user-config', 
+    ] 
+ 
+    def initialize_options(self): 
+        self.global_config = None 
+        self.user_config = None 
+        self.filename = None 
+ 
+    def finalize_options(self): 
+        filenames = [] 
+        if self.global_config: 
+            filenames.append(config_file('global')) 
+        if self.user_config: 
+            filenames.append(config_file('user')) 
+        if self.filename is not None: 
+            filenames.append(self.filename) 
+        if not filenames: 
+            filenames.append(config_file('local')) 
+        if len(filenames) > 1: 
+            raise DistutilsOptionError( 
+                "Must specify only one configuration file option", 
+                filenames 
+            ) 
+        self.filename, = filenames 
+ 
+ 
+class setopt(option_base): 
+    """Save command-line options to a file""" 
+ 
+    description = "set an option in setup.cfg or another config file" 
+ 
+    user_options = [ 
+        ('command=', 'c', 'command to set an option for'), 
+        ('option=', 'o', 'option to set'), 
+        ('set-value=', 's', 'value of the option'), 
+        ('remove', 'r', 'remove (unset) the value'), 
+    ] + option_base.user_options 
+ 
+    boolean_options = option_base.boolean_options + ['remove'] 
+ 
+    def initialize_options(self): 
+        option_base.initialize_options(self) 
+        self.command = None 
+        self.option = None 
+        self.set_value = None 
+        self.remove = None 
+ 
+    def finalize_options(self): 
+        option_base.finalize_options(self) 
+        if self.command is None or self.option is None: 
+            raise DistutilsOptionError("Must specify --command *and* --option") 
+        if self.set_value is None and not self.remove: 
+            raise DistutilsOptionError("Must specify --set-value or --remove") 
+ 
+    def run(self): 
+        edit_config( 
+            self.filename, { 
+                self.command: {self.option.replace('-', '_'): self.set_value} 
+            }, 
+            self.dry_run 
+        ) 
diff --git a/contrib/python/setuptools/py2/setuptools/command/test.py b/contrib/python/setuptools/py2/setuptools/command/test.py
index f6470e9c34..dfccc90a8d 100644
--- a/contrib/python/setuptools/py2/setuptools/command/test.py
+++ b/contrib/python/setuptools/py2/setuptools/command/test.py
@@ -6,121 +6,121 @@ import itertools
 import unittest
 from distutils.errors import DistutilsError, DistutilsOptionError
 from distutils import log
-from unittest import TestLoader
-
+from unittest import TestLoader 
+ 
 from setuptools.extern import six
 from setuptools.extern.six.moves import map, filter
-
-from pkg_resources import (resource_listdir, resource_exists, normalize_path,
+ 
+from pkg_resources import (resource_listdir, resource_exists, normalize_path, 
                            working_set, _namespace_packages, evaluate_marker,
-                           add_activation_listener, require, EntryPoint)
-from setuptools import Command
+                           add_activation_listener, require, EntryPoint) 
+from setuptools import Command 
 from .build_py import _unique_everseen
-
+ 
 __metaclass__ = type
+ 
 
-
-class ScanningLoader(TestLoader):
+class ScanningLoader(TestLoader): 
 
     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
-
-        If the module is a package, load tests from all the modules in it.
-        If the module has an ``additional_tests`` function, call it and add
-        the return value to the tests.
-        """
+    def loadTestsFromModule(self, module, pattern=None): 
+        """Return a suite of all tests cases contained in the given module 
+ 
+        If the module is a package, load tests from all the modules in it. 
+        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)
 
-        tests = []
-        tests.append(TestLoader.loadTestsFromModule(self, module))
-
-        if hasattr(module, "additional_tests"):
-            tests.append(module.additional_tests())
-
-        if hasattr(module, '__path__'):
-            for file in resource_listdir(module.__name__, ''):
-                if file.endswith('.py') and file != '__init__.py':
-                    submodule = module.__name__ + '.' + file[:-3]
-                else:
-                    if resource_exists(module.__name__, file + '/__init__.py'):
-                        submodule = module.__name__ + '.' + file
-                    else:
-                        continue
-                tests.append(self.loadTestsFromName(submodule))
-
-        if len(tests) != 1:
-            return self.suiteClass(tests)
-        else:
-            return tests[0]  # don't create a nested suite for only one return
-
-
-# adapted from jaraco.classes.properties:NonDataProperty
+        tests = [] 
+        tests.append(TestLoader.loadTestsFromModule(self, module)) 
+ 
+        if hasattr(module, "additional_tests"): 
+            tests.append(module.additional_tests()) 
+ 
+        if hasattr(module, '__path__'): 
+            for file in resource_listdir(module.__name__, ''): 
+                if file.endswith('.py') and file != '__init__.py': 
+                    submodule = module.__name__ + '.' + file[:-3] 
+                else: 
+                    if resource_exists(module.__name__, file + '/__init__.py'): 
+                        submodule = module.__name__ + '.' + file 
+                    else: 
+                        continue 
+                tests.append(self.loadTestsFromName(submodule)) 
+ 
+        if len(tests) != 1: 
+            return self.suiteClass(tests) 
+        else: 
+            return tests[0]  # don't create a nested suite for only one return 
+ 
+ 
+# adapted from jaraco.classes.properties:NonDataProperty 
 class NonDataProperty:
-    def __init__(self, fget):
-        self.fget = fget
-
-    def __get__(self, obj, objtype=None):
-        if obj is None:
-            return self
-        return self.fget(obj)
-
-
-class test(Command):
-    """Command to run unit tests after in-place build"""
-
+    def __init__(self, fget): 
+        self.fget = fget 
+ 
+    def __get__(self, obj, objtype=None): 
+        if obj is None: 
+            return self 
+        return self.fget(obj) 
+ 
+ 
+class test(Command): 
+    """Command to run unit tests after in-place build""" 
+ 
     description = "run unit tests after in-place build (deprecated)"
-
-    user_options = [
-        ('test-module=', 'm', "Run 'test_suite' in specified module"),
-        ('test-suite=', 's',
+ 
+    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')"),
-        ('test-runner=', 'r', "Test runner to use"),
-    ]
-
-    def initialize_options(self):
-        self.test_suite = None
-        self.test_module = None
-        self.test_loader = None
-        self.test_runner = None
-
-    def finalize_options(self):
-
-        if self.test_suite and self.test_module:
-            msg = "You may specify a module or a suite, but not both"
-            raise DistutilsOptionError(msg)
-
-        if self.test_suite is None:
-            if self.test_module is None:
-                self.test_suite = self.distribution.test_suite
-            else:
-                self.test_suite = self.test_module + ".test_suite"
-
-        if self.test_loader is None:
-            self.test_loader = getattr(self.distribution, 'test_loader', None)
-        if self.test_loader is None:
-            self.test_loader = "setuptools.command.test:ScanningLoader"
-        if self.test_runner is None:
-            self.test_runner = getattr(self.distribution, 'test_runner', None)
-
-    @NonDataProperty
-    def test_args(self):
-        return list(self._test_args())
-
-    def _test_args(self):
+        ('test-runner=', 'r', "Test runner to use"), 
+    ] 
+ 
+    def initialize_options(self): 
+        self.test_suite = None 
+        self.test_module = None 
+        self.test_loader = None 
+        self.test_runner = None 
+ 
+    def finalize_options(self): 
+ 
+        if self.test_suite and self.test_module: 
+            msg = "You may specify a module or a suite, but not both" 
+            raise DistutilsOptionError(msg) 
+ 
+        if self.test_suite is None: 
+            if self.test_module is None: 
+                self.test_suite = self.distribution.test_suite 
+            else: 
+                self.test_suite = self.test_module + ".test_suite" 
+ 
+        if self.test_loader is None: 
+            self.test_loader = getattr(self.distribution, 'test_loader', None) 
+        if self.test_loader is None: 
+            self.test_loader = "setuptools.command.test:ScanningLoader" 
+        if self.test_runner is None: 
+            self.test_runner = getattr(self.distribution, 'test_runner', None) 
+ 
+    @NonDataProperty 
+    def test_args(self): 
+        return list(self._test_args()) 
+ 
+    def _test_args(self): 
         if not self.test_suite and sys.version_info >= (2, 7):
             yield 'discover'
-        if self.verbose:
-            yield '--verbose'
-        if self.test_suite:
-            yield self.test_suite
-
-    def with_project_on_sys_path(self, func):
+        if self.verbose: 
+            yield '--verbose' 
+        if self.test_suite: 
+            yield self.test_suite 
+ 
+    def with_project_on_sys_path(self, func): 
         """
         Backward compatibility for project_on_sys_path context.
         """
@@ -130,49 +130,49 @@ 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)
-
-        if with_2to3:
-            # 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 = normalize_path(bpy_cmd.build_lib)
-
-            # Build extensions
-            self.reinitialize_command('egg_info', egg_base=build_path)
-            self.run_command('egg_info')
-
-            self.reinitialize_command('build_ext', inplace=0)
-            self.run_command('build_ext')
-        else:
-            # Without 2to3 inplace works fine:
-            self.run_command('egg_info')
-
-            # Build extensions in-place
-            self.reinitialize_command('build_ext', inplace=1)
-            self.run_command('build_ext')
-
-        ei_cmd = self.get_finalized_command("egg_info")
-
-        old_path = sys.path[:]
-        old_modules = sys.modules.copy()
-
-        try:
+ 
+        if with_2to3: 
+            # 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 = normalize_path(bpy_cmd.build_lib) 
+ 
+            # Build extensions 
+            self.reinitialize_command('egg_info', egg_base=build_path) 
+            self.run_command('egg_info') 
+ 
+            self.reinitialize_command('build_ext', inplace=0) 
+            self.run_command('build_ext') 
+        else: 
+            # Without 2to3 inplace works fine: 
+            self.run_command('egg_info') 
+ 
+            # Build extensions in-place 
+            self.reinitialize_command('build_ext', inplace=1) 
+            self.run_command('build_ext') 
+ 
+        ei_cmd = self.get_finalized_command("egg_info") 
+ 
+        old_path = sys.path[:] 
+        old_modules = sys.modules.copy() 
+ 
+        try: 
             project_path = normalize_path(ei_cmd.egg_base)
             sys.path.insert(0, project_path)
-            working_set.__init__()
-            add_activation_listener(lambda dist: dist.activate())
-            require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
+            working_set.__init__() 
+            add_activation_listener(lambda dist: dist.activate()) 
+            require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version)) 
             with self.paths_on_pythonpath([project_path]):
                 yield
-        finally:
-            sys.path[:] = old_path
-            sys.modules.clear()
-            sys.modules.update(old_modules)
-            working_set.__init__()
-
+        finally: 
+            sys.path[:] = old_path 
+            sys.modules.clear() 
+            sys.modules.update(old_modules) 
+            working_set.__init__() 
+ 
     @staticmethod
     @contextlib.contextmanager
     def paths_on_pythonpath(paths):
@@ -213,7 +213,7 @@ class test(Command):
         )
         return itertools.chain(ir_d, tr_d, er_d)
 
-    def run(self):
+    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 "
@@ -223,12 +223,12 @@ class test(Command):
         )
 
         installed_dists = self.install_dists(self.distribution)
-
-        cmd = ' '.join(self._argv)
-        if self.dry_run:
-            self.announce('skipping "%s" (dry run)' % cmd)
+ 
+        cmd = ' '.join(self._argv) 
+        if self.dry_run: 
+            self.announce('skipping "%s" (dry run)' % cmd) 
             return
-
+ 
         self.announce('running "%s"' % cmd)
 
         paths = map(operator.attrgetter('location'), installed_dists)
@@ -236,44 +236,44 @@ class test(Command):
             with self.project_on_sys_path():
                 self.run_tests()
 
-    def run_tests(self):
-        # 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.
+    def run_tests(self): 
+        # 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):
-            module = self.test_suite.split('.')[0]
-            if module in _namespace_packages:
-                del_modules = []
-                if module in sys.modules:
-                    del_modules.append(module)
-                module += '.'
-                for name in sys.modules:
-                    if name.startswith(module):
-                        del_modules.append(name)
-                list(map(sys.modules.__delitem__, del_modules))
-
+            module = self.test_suite.split('.')[0] 
+            if module in _namespace_packages: 
+                del_modules = [] 
+                if module in sys.modules: 
+                    del_modules.append(module) 
+                module += '.' 
+                for name in sys.modules: 
+                    if name.startswith(module): 
+                        del_modules.append(name) 
+                list(map(sys.modules.__delitem__, del_modules)) 
+ 
         test = unittest.main(
-            None, None, self._argv,
-            testLoader=self._resolve_as_ep(self.test_loader),
-            testRunner=self._resolve_as_ep(self.test_runner),
+            None, None, self._argv, 
+            testLoader=self._resolve_as_ep(self.test_loader), 
+            testRunner=self._resolve_as_ep(self.test_runner), 
             exit=False,
-        )
+        ) 
         if not test.result.wasSuccessful():
             msg = 'Test failed: %s' % test.result
             self.announce(msg, log.ERROR)
             raise DistutilsError(msg)
-
-    @property
-    def _argv(self):
-        return ['unittest'] + self.test_args
-
-    @staticmethod
-    def _resolve_as_ep(val):
-        """
-        Load the indicated attribute value, called, as a as if it were
-        specified as an entry point.
-        """
-        if val is None:
-            return
-        parsed = EntryPoint.parse("x=" + val)
-        return parsed.resolve()()
+ 
+    @property 
+    def _argv(self): 
+        return ['unittest'] + self.test_args 
+ 
+    @staticmethod 
+    def _resolve_as_ep(val): 
+        """ 
+        Load the indicated attribute value, called, as a as if it were 
+        specified as an entry point. 
+        """ 
+        if val is None: 
+            return 
+        parsed = EntryPoint.parse("x=" + val) 
+        return parsed.resolve()() 
diff --git a/contrib/python/setuptools/py2/setuptools/command/upload_docs.py b/contrib/python/setuptools/py2/setuptools/command/upload_docs.py
index 130a0cb6c9..ca84dfc322 100644
--- a/contrib/python/setuptools/py2/setuptools/command/upload_docs.py
+++ b/contrib/python/setuptools/py2/setuptools/command/upload_docs.py
@@ -1,107 +1,107 @@
-# -*- coding: utf-8 -*-
-"""upload_docs
-
-Implements a Distutils 'upload_docs' subcommand (upload documentation to
-PyPI's pythonhosted.org).
-"""
-
-from base64 import standard_b64encode
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import os
-import socket
-import zipfile
-import tempfile
-import shutil
+# -*- coding: utf-8 -*- 
+"""upload_docs 
+ 
+Implements a Distutils 'upload_docs' subcommand (upload documentation to 
+PyPI's pythonhosted.org). 
+""" 
+ 
+from base64 import standard_b64encode 
+from distutils import log 
+from distutils.errors import DistutilsOptionError 
+import os 
+import socket 
+import zipfile 
+import tempfile 
+import shutil 
 import itertools
 import functools
-
+ 
 from setuptools.extern import six
 from setuptools.extern.six.moves import http_client, urllib
-
-from pkg_resources import iter_entry_points
+ 
+from pkg_resources import iter_entry_points 
 from .upload import upload
-
-
+ 
+ 
 def _encode(s):
     errors = 'strict' if six.PY2 else 'surrogateescape'
     return s.encode('utf-8', errors)
-
-
+ 
+ 
 class upload_docs(upload):
     # override the default repository as upload_docs isn't
     # supported by Warehouse (and won't be).
     DEFAULT_REPOSITORY = 'https://pypi.python.org/pypi/'
-
-    description = 'Upload documentation to PyPI'
-
-    user_options = [
-        ('repository=', 'r',
-         "url of repository [default: %s]" % upload.DEFAULT_REPOSITORY),
-        ('show-response', None,
-         'display full response text from server'),
-        ('upload-dir=', None, 'directory to upload'),
-    ]
-    boolean_options = upload.boolean_options
-
-    def has_sphinx(self):
-        if self.upload_dir is None:
-            for ep in iter_entry_points('distutils.commands', 'build_sphinx'):
-                return True
-
-    sub_commands = [('build_sphinx', has_sphinx)]
-
-    def initialize_options(self):
-        upload.initialize_options(self)
-        self.upload_dir = None
-        self.target_dir = None
-
-    def finalize_options(self):
-        upload.finalize_options(self)
-        if self.upload_dir is None:
-            if self.has_sphinx():
-                build_sphinx = self.get_finalized_command('build_sphinx')
-                self.target_dir = build_sphinx.builder_target_dir
-            else:
-                build = self.get_finalized_command('build')
-                self.target_dir = os.path.join(build.build_base, 'docs')
-        else:
-            self.ensure_dirname('upload_dir')
-            self.target_dir = self.upload_dir
+ 
+    description = 'Upload documentation to PyPI' 
+ 
+    user_options = [ 
+        ('repository=', 'r', 
+         "url of repository [default: %s]" % upload.DEFAULT_REPOSITORY), 
+        ('show-response', None, 
+         'display full response text from server'), 
+        ('upload-dir=', None, 'directory to upload'), 
+    ] 
+    boolean_options = upload.boolean_options 
+ 
+    def has_sphinx(self): 
+        if self.upload_dir is None: 
+            for ep in iter_entry_points('distutils.commands', 'build_sphinx'): 
+                return True 
+ 
+    sub_commands = [('build_sphinx', has_sphinx)] 
+ 
+    def initialize_options(self): 
+        upload.initialize_options(self) 
+        self.upload_dir = None 
+        self.target_dir = None 
+ 
+    def finalize_options(self): 
+        upload.finalize_options(self) 
+        if self.upload_dir is None: 
+            if self.has_sphinx(): 
+                build_sphinx = self.get_finalized_command('build_sphinx') 
+                self.target_dir = build_sphinx.builder_target_dir 
+            else: 
+                build = self.get_finalized_command('build') 
+                self.target_dir = os.path.join(build.build_base, 'docs') 
+        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.")
-        self.announce('Using upload directory %s' % self.target_dir)
-
-    def create_zipfile(self, filename):
-        zip_file = zipfile.ZipFile(filename, "w")
-        try:
-            self.mkpath(self.target_dir)  # just in case
-            for root, dirs, files in os.walk(self.target_dir):
-                if root == self.target_dir and not files:
+        self.announce('Using upload directory %s' % self.target_dir) 
+ 
+    def create_zipfile(self, filename): 
+        zip_file = zipfile.ZipFile(filename, "w") 
+        try: 
+            self.mkpath(self.target_dir)  # just in case 
+            for root, dirs, files in os.walk(self.target_dir): 
+                if root == self.target_dir and not files: 
                     tmpl = "no files found in upload directory '%s'"
                     raise DistutilsOptionError(tmpl % self.target_dir)
-                for name in files:
-                    full = os.path.join(root, name)
-                    relative = root[len(self.target_dir):].lstrip(os.path.sep)
-                    dest = os.path.join(relative, name)
-                    zip_file.write(full, dest)
-        finally:
-            zip_file.close()
-
-    def run(self):
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        tmp_dir = tempfile.mkdtemp()
-        name = self.distribution.metadata.get_name()
-        zip_file = os.path.join(tmp_dir, "%s.zip" % name)
-        try:
-            self.create_zipfile(zip_file)
-            self.upload_file(zip_file)
-        finally:
-            shutil.rmtree(tmp_dir)
-
+                for name in files: 
+                    full = os.path.join(root, name) 
+                    relative = root[len(self.target_dir):].lstrip(os.path.sep) 
+                    dest = os.path.join(relative, name) 
+                    zip_file.write(full, dest) 
+        finally: 
+            zip_file.close() 
+ 
+    def run(self): 
+        # Run sub commands 
+        for cmd_name in self.get_sub_commands(): 
+            self.run_command(cmd_name) 
+ 
+        tmp_dir = tempfile.mkdtemp() 
+        name = self.distribution.metadata.get_name() 
+        zip_file = os.path.join(tmp_dir, "%s.zip" % name) 
+        try: 
+            self.create_zipfile(zip_file) 
+            self.upload_file(zip_file) 
+        finally: 
+            shutil.rmtree(tmp_dir) 
+ 
     @staticmethod
     def _build_part(item, sep_boundary):
         key, values = item
@@ -141,66 +141,66 @@ class upload_docs(upload):
         content_type = 'multipart/form-data; boundary=%s' % boundary.decode('ascii')
         return b''.join(body_items), content_type
 
-    def upload_file(self, filename):
+    def upload_file(self, filename): 
         with open(filename, 'rb') as f:
             content = f.read()
-        meta = self.distribution.metadata
-        data = {
-            ':action': 'doc_upload',
-            'name': meta.get_name(),
-            'content': (os.path.basename(filename), content),
-        }
-        # set up the authentication
+        meta = self.distribution.metadata 
+        data = { 
+            ':action': 'doc_upload', 
+            'name': meta.get_name(), 
+            'content': (os.path.basename(filename), content), 
+        } 
+        # set up the authentication 
         credentials = _encode(self.username + ':' + self.password)
-        credentials = standard_b64encode(credentials)
+        credentials = standard_b64encode(credentials) 
         if not six.PY2:
-            credentials = credentials.decode('ascii')
-        auth = "Basic " + credentials
-
+            credentials = credentials.decode('ascii') 
+        auth = "Basic " + credentials 
+ 
         body, ct = self._build_multipart(data)
-
+ 
         msg = "Submitting documentation to %s" % (self.repository)
         self.announce(msg, log.INFO)
-
-        # build the Request
-        # We can't use urllib2 since we need to send the Basic
-        # auth right with the first request
-        schema, netloc, url, params, query, fragments = \
-            urllib.parse.urlparse(self.repository)
-        assert not params and not query and not fragments
-        if schema == 'http':
-            conn = http_client.HTTPConnection(netloc)
-        elif schema == 'https':
-            conn = http_client.HTTPSConnection(netloc)
-        else:
-            raise AssertionError("unsupported schema " + schema)
-
-        data = ''
-        try:
-            conn.connect()
-            conn.putrequest("POST", url)
+ 
+        # build the Request 
+        # We can't use urllib2 since we need to send the Basic 
+        # auth right with the first request 
+        schema, netloc, url, params, query, fragments = \ 
+            urllib.parse.urlparse(self.repository) 
+        assert not params and not query and not fragments 
+        if schema == 'http': 
+            conn = http_client.HTTPConnection(netloc) 
+        elif schema == 'https': 
+            conn = http_client.HTTPSConnection(netloc) 
+        else: 
+            raise AssertionError("unsupported schema " + schema) 
+ 
+        data = '' 
+        try: 
+            conn.connect() 
+            conn.putrequest("POST", url) 
             content_type = ct
-            conn.putheader('Content-type', content_type)
-            conn.putheader('Content-length', str(len(body)))
-            conn.putheader('Authorization', auth)
-            conn.endheaders()
-            conn.send(body)
-        except socket.error as e:
-            self.announce(str(e), log.ERROR)
-            return
-
-        r = conn.getresponse()
-        if r.status == 200:
+            conn.putheader('Content-type', content_type) 
+            conn.putheader('Content-length', str(len(body))) 
+            conn.putheader('Authorization', auth) 
+            conn.endheaders() 
+            conn.send(body) 
+        except socket.error as e: 
+            self.announce(str(e), log.ERROR) 
+            return 
+ 
+        r = conn.getresponse() 
+        if r.status == 200: 
             msg = 'Server response (%s): %s' % (r.status, r.reason)
             self.announce(msg, log.INFO)
-        elif r.status == 301:
-            location = r.getheader('Location')
-            if location is None:
-                location = 'https://pythonhosted.org/%s/' % meta.get_name()
+        elif r.status == 301: 
+            location = r.getheader('Location') 
+            if location is None: 
+                location = 'https://pythonhosted.org/%s/' % meta.get_name() 
             msg = 'Upload successful. Visit %s' % location
             self.announce(msg, log.INFO)
-        else:
+        else: 
             msg = 'Upload failed (%s): %s' % (r.status, r.reason)
             self.announce(msg, log.ERROR)
-        if self.show_response:
-            print('-' * 75, r.read(), '-' * 75)
+        if self.show_response: 
+            print('-' * 75, r.read(), '-' * 75) 
diff --git a/contrib/python/setuptools/py2/setuptools/depends.py b/contrib/python/setuptools/py2/setuptools/depends.py
index a37675cbd9..bc2b767ff1 100644
--- a/contrib/python/setuptools/py2/setuptools/depends.py
+++ b/contrib/python/setuptools/py2/setuptools/depends.py
@@ -1,87 +1,87 @@
-import sys
-import marshal
+import sys 
+import marshal 
 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
 
 
-__all__ = [
-    'Require', 'find_module', 'get_module_constant', 'extract_constant'
-]
-
-
-class Require:
-    """A prerequisite to building or installing a distribution"""
+__all__ = [ 
+    'Require', 'find_module', 'get_module_constant', 'extract_constant' 
+] 
+ 
 
+class Require: 
+    """A prerequisite to building or installing a distribution""" 
+ 
     def __init__(
             self, name, requested_version, module, homepage='',
-            attribute=None, format=None):
-
-        if format is None and requested_version is not None:
-            format = StrictVersion
-
-        if format is not None:
-            requested_version = format(requested_version)
-            if attribute is None:
-                attribute = '__version__'
-
-        self.__dict__.update(locals())
-        del self.self
-
-    def full_name(self):
-        """Return full package/distribution name, w/version"""
-        if self.requested_version is not None:
+            attribute=None, format=None): 
+ 
+        if format is None and requested_version is not None: 
+            format = StrictVersion 
+ 
+        if format is not None: 
+            requested_version = format(requested_version) 
+            if attribute is None: 
+                attribute = '__version__' 
+ 
+        self.__dict__.update(locals()) 
+        del self.self 
+ 
+    def full_name(self): 
+        """Return full package/distribution name, w/version""" 
+        if self.requested_version is not None: 
             return '%s-%s' % (self.name, self.requested_version)
-        return self.name
-
-    def version_ok(self, version):
-        """Is 'version' sufficiently up-to-date?"""
-        return self.attribute is None or self.format is None or \
-            str(version) != "unknown" and version >= self.requested_version
-
-    def get_version(self, paths=None, default="unknown"):
-        """Get version number of installed module, 'None', or 'default'
-
-        Search 'paths' for module.  If not found, return 'None'.  If found,
-        return the extracted version attribute, or 'default' if no version
-        attribute was specified, or the value cannot be determined without
-        importing the module.  The version is formatted according to the
-        requirement's version format (if any), unless it is 'None' or the
-        supplied 'default'.
-        """
-
-        if self.attribute is None:
-            try:
+        return self.name 
+ 
+    def version_ok(self, version): 
+        """Is 'version' sufficiently up-to-date?""" 
+        return self.attribute is None or self.format is None or \ 
+            str(version) != "unknown" and version >= self.requested_version 
+ 
+    def get_version(self, paths=None, default="unknown"): 
+        """Get version number of installed module, 'None', or 'default' 
+ 
+        Search 'paths' for module.  If not found, return 'None'.  If found, 
+        return the extracted version attribute, or 'default' if no version 
+        attribute was specified, or the value cannot be determined without 
+        importing the module.  The version is formatted according to the 
+        requirement's version format (if any), unless it is 'None' or the 
+        supplied 'default'. 
+        """ 
+ 
+        if self.attribute is None: 
+            try: 
                 f, p, i = find_module(self.module, paths)
                 if f:
                     f.close()
-                return default
-            except ImportError:
-                return None
-
-        v = get_module_constant(self.module, self.attribute, default, paths)
-
-        if v is not None and v is not default and self.format is not None:
-            return self.format(v)
-
-        return v
-
-    def is_present(self, paths=None):
-        """Return true if dependency is present on 'paths'"""
-        return self.get_version(paths) is not None
-
-    def is_current(self, paths=None):
-        """Return true if dependency is present and up-to-date on 'paths'"""
-        version = self.get_version(paths)
-        if version is None:
-            return False
-        return self.version_ok(version)
-
-
+                return default 
+            except ImportError: 
+                return None 
+ 
+        v = get_module_constant(self.module, self.attribute, default, paths) 
+ 
+        if v is not None and v is not default and self.format is not None: 
+            return self.format(v) 
+ 
+        return v 
+ 
+    def is_present(self, paths=None): 
+        """Return true if dependency is present on 'paths'""" 
+        return self.get_version(paths) is not None 
+ 
+    def is_current(self, paths=None): 
+        """Return true if dependency is present and up-to-date on 'paths'""" 
+        version = self.get_version(paths) 
+        if version is None: 
+            return False 
+        return self.version_ok(version) 
+ 
+ 
 def maybe_close(f):
     @contextlib.contextmanager
     def empty():
@@ -89,88 +89,88 @@ def maybe_close(f):
         return
     if not f:
         return empty()
-
+ 
     return contextlib.closing(f)
-
-
-def get_module_constant(module, symbol, default=-1, paths=None):
-    """Find 'module' by searching 'paths', and extract 'symbol'
-
-    Return 'None' if 'module' does not exist on 'paths', or it does not define
-    'symbol'.  If the module defines 'symbol' as a constant, return the
-    constant.  Otherwise, return 'default'."""
-
-    try:
+ 
+ 
+def get_module_constant(module, symbol, default=-1, paths=None): 
+    """Find 'module' by searching 'paths', and extract 'symbol' 
+ 
+    Return 'None' if 'module' does not exist on 'paths', or it does not define 
+    'symbol'.  If the module defines 'symbol' as a constant, return the 
+    constant.  Otherwise, return 'default'.""" 
+ 
+    try: 
         f, path, (suffix, mode, kind) = info = find_module(module, paths)
-    except ImportError:
-        # Module doesn't exist
-        return None
-
+    except ImportError: 
+        # Module doesn't exist 
+        return None 
+ 
     with maybe_close(f):
         if kind == PY_COMPILED:
             f.read(8)  # skip magic & date
-            code = marshal.load(f)
+            code = marshal.load(f) 
         elif kind == PY_FROZEN:
             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.  :(
+            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)
-
-    return extract_constant(code, symbol, default)
-
-
-def extract_constant(code, symbol, default=-1):
-    """Extract the constant value of 'symbol' from 'code'
-
-    If the name 'symbol' is bound to a constant value by the Python code
-    object 'code', return that value.  If 'symbol' is bound to an expression,
-    return 'default'.  Otherwise, return 'None'.
-
-    Return value is based on the first assignment to 'symbol'.  'symbol' must
-    be a global, or at least a non-"fast" local in the code block.  That is,
-    only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
-    must be present in 'code.co_names'.
-    """
-    if symbol not in code.co_names:
+ 
+    return extract_constant(code, symbol, default) 
+ 
+ 
+def extract_constant(code, symbol, default=-1): 
+    """Extract the constant value of 'symbol' from 'code' 
+ 
+    If the name 'symbol' is bound to a constant value by the Python code 
+    object 'code', return that value.  If 'symbol' is bound to an expression, 
+    return 'default'.  Otherwise, return 'None'. 
+ 
+    Return value is based on the first assignment to 'symbol'.  'symbol' must 
+    be a global, or at least a non-"fast" local in the code block.  That is, 
+    only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol' 
+    must be present in 'code.co_names'. 
+    """ 
+    if symbol not in code.co_names: 
         # name's not there, can't possibly be an assignment
-        return None
-
-    name_idx = list(code.co_names).index(symbol)
-
-    STORE_NAME = 90
-    STORE_GLOBAL = 97
-    LOAD_CONST = 100
-
-    const = default
-
+        return None 
+ 
+    name_idx = list(code.co_names).index(symbol) 
+ 
+    STORE_NAME = 90 
+    STORE_GLOBAL = 97 
+    LOAD_CONST = 100 
+ 
+    const = default 
+ 
     for byte_code in Bytecode(code):
         op = byte_code.opcode
         arg = byte_code.arg
-
+ 
         if op == LOAD_CONST:
-            const = code.co_consts[arg]
+            const = code.co_consts[arg] 
         elif arg == name_idx and (op == STORE_NAME or op == STORE_GLOBAL):
-            return const
-        else:
-            const = default
-
-
-def _update_globals():
-    """
-    Patch the globals to remove the objects not available on some platforms.
-
-    XXX it'd be better to test assertions about bytecode instead.
-    """
-
-    if not sys.platform.startswith('java') and sys.platform != 'cli':
-        return
-    incompatible = 'extract_constant', 'get_module_constant'
-    for name in incompatible:
-        del globals()[name]
-        __all__.remove(name)
-
-
-_update_globals()
+            return const 
+        else: 
+            const = default 
+ 
+ 
+def _update_globals(): 
+    """ 
+    Patch the globals to remove the objects not available on some platforms. 
+ 
+    XXX it'd be better to test assertions about bytecode instead. 
+    """ 
+ 
+    if not sys.platform.startswith('java') and sys.platform != 'cli': 
+        return 
+    incompatible = 'extract_constant', 'get_module_constant' 
+    for name in incompatible: 
+        del globals()[name] 
+        __all__.remove(name) 
+ 
+
+_update_globals() 
diff --git a/contrib/python/setuptools/py2/setuptools/dist.py b/contrib/python/setuptools/py2/setuptools/dist.py
index f6453a0878..c381b4ac54 100644
--- a/contrib/python/setuptools/py2/setuptools/dist.py
+++ b/contrib/python/setuptools/py2/setuptools/dist.py
@@ -1,16 +1,16 @@
 # -*- coding: utf-8 -*-
-__all__ = ['Distribution']
-
+__all__ = ['Distribution'] 
+ 
 import io
 import sys
-import re
-import os
-import warnings
-import numbers
-import distutils.log
-import distutils.core
-import distutils.cmd
-import distutils.dist
+import re 
+import os 
+import warnings 
+import numbers 
+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
@@ -24,28 +24,28 @@ from distutils.errors import (
 )
 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 . import SetuptoolsDeprecationWarning
 
-from setuptools.depends import Require
-from setuptools import windows_support
+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 pkg_resources 
+ 
 __import__('setuptools.extern.packaging.specifiers')
 __import__('setuptools.extern.packaging.version')
+ 
 
-
-def _get_unpatched(cls):
+def _get_unpatched(cls): 
     warnings.warn("Do not call this function", DistDeprecationWarning)
     return get_unpatched(cls)
-
+ 
 
 def get_metadata_version(self):
     mv = getattr(self, 'metadata_version', None)
@@ -125,9 +125,9 @@ def read_pkg_file(self, file):
 # 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)))
@@ -163,7 +163,7 @@ def write_pkg_file(self, file):
         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)
 
@@ -198,64 +198,64 @@ def write_pkg_file(self, file):
         for extra in self.provides_extras:
             write_field('Provides-Extra', extra)
 
+ 
+sequence = tuple, list 
+ 
 
-sequence = tuple, list
-
-
-def check_importable(dist, attr, value):
-    try:
+def check_importable(dist, attr, value): 
+    try: 
         ep = pkg_resources.EntryPoint.parse('x=' + value)
-        assert not ep.extras
+        assert not ep.extras 
     except (TypeError, ValueError, AttributeError, AssertionError):
-        raise DistutilsSetupError(
-            "%r must be importable 'module:attrs' string (got %r)"
+        raise DistutilsSetupError( 
+            "%r must be importable 'module:attrs' string (got %r)" 
             % (attr, value)
-        )
-
-
-def assert_string_list(dist, attr, value):
+        ) 
+ 
+ 
+def assert_string_list(dist, attr, value): 
     """Verify that value is a string list"""
-    try:
+    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
         assert ''.join(value) != value
     except (TypeError, ValueError, AttributeError, AssertionError):
-        raise DistutilsSetupError(
+        raise DistutilsSetupError( 
             "%r must be a list of strings (got %r)" % (attr, value)
-        )
+        ) 
 
 
-def check_nsp(dist, attr, value):
-    """Verify that namespace packages are valid"""
+def check_nsp(dist, attr, value): 
+    """Verify that namespace packages are valid""" 
     ns_packages = value
     assert_string_list(dist, attr, ns_packages)
     for nsp in ns_packages:
-        if not dist.has_contents_for(nsp):
-            raise DistutilsSetupError(
-                "Distribution contains no modules or packages for " +
-                "namespace package %r" % nsp
-            )
+        if not dist.has_contents_for(nsp): 
+            raise DistutilsSetupError( 
+                "Distribution contains no modules or packages for " + 
+                "namespace package %r" % nsp 
+            ) 
         parent, sep, child = nsp.rpartition('.')
         if parent and parent not in ns_packages:
             distutils.log.warn(
                 "WARNING: %r is declared as a package namespace, but %r"
                 " is not: please correct this in setup.py", nsp, parent
             )
+ 
 
-
-def check_extras(dist, attr, value):
-    """Verify that extras_require mapping is valid"""
-    try:
+def check_extras(dist, attr, value): 
+    """Verify that extras_require mapping is valid""" 
+    try: 
         list(itertools.starmap(_check_extra, value.items()))
     except (TypeError, ValueError, AttributeError):
-        raise DistutilsSetupError(
-            "'extras_require' must be a dictionary whose values are "
-            "strings or lists of strings containing valid project/version "
-            "requirement specifiers."
-        )
-
+        raise DistutilsSetupError( 
+            "'extras_require' must be a dictionary whose values are " 
+            "strings or lists of strings containing valid project/version " 
+            "requirement specifiers." 
+        ) 
+ 
 
 def _check_extra(extra, reqs):
     name, sep, marker = extra.partition(':')
@@ -264,26 +264,26 @@ def _check_extra(extra, reqs):
     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:
-        tmpl = "{attr!r} must be a boolean value (got {value!r})"
-        raise DistutilsSetupError(tmpl.format(attr=attr, value=value))
-
-
-def check_requirements(dist, attr, value):
-    """Verify that install_requires is a valid requirements list"""
-    try:
-        list(pkg_resources.parse_requirements(value))
+def assert_bool(dist, attr, value): 
+    """Verify that value is True, False, 0, or 1""" 
+    if bool(value) != value: 
+        tmpl = "{attr!r} must be a boolean value (got {value!r})" 
+        raise DistutilsSetupError(tmpl.format(attr=attr, value=value)) 
+ 
+ 
+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")
-    except (TypeError, ValueError) as error:
-        tmpl = (
-            "{attr!r} must be a string or list of strings "
-            "containing valid project/version requirement specifiers; {error}"
-        )
-        raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
-
+    except (TypeError, ValueError) as error: 
+        tmpl = ( 
+            "{attr!r} must be a string or list of strings " 
+            "containing valid project/version requirement specifiers; {error}" 
+        ) 
+        raise DistutilsSetupError(tmpl.format(attr=attr, error=error)) 
+ 
 
 def check_specifier(dist, attr, value):
     """Verify that value is a valid version specifier"""
@@ -297,21 +297,21 @@ def check_specifier(dist, attr, value):
         raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
 
 
-def check_entry_points(dist, attr, value):
-    """Verify that entry_points map is parseable"""
-    try:
-        pkg_resources.EntryPoint.parse_map(value)
-    except ValueError as e:
-        raise DistutilsSetupError(e)
+def check_entry_points(dist, attr, value): 
+    """Verify that entry_points map is parseable""" 
+    try: 
+        pkg_resources.EntryPoint.parse_map(value) 
+    except ValueError as e: 
+        raise DistutilsSetupError(e) 
+ 
 
+def check_test_suite(dist, attr, value): 
+    if not isinstance(value, six.string_types): 
+        raise DistutilsSetupError("test_suite must be a string") 
+ 
 
-def check_test_suite(dist, attr, value):
-    if not isinstance(value, six.string_types):
-        raise DistutilsSetupError("test_suite must be a string")
-
-
-def check_package_data(dist, attr, value):
-    """Verify that value is a dictionary of package names to glob lists"""
+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 "
@@ -323,88 +323,88 @@ def check_package_data(dist, attr, value):
                 .format(attr, k)
             )
         assert_string_list(dist, 'values of {!r} dict'.format(attr), v)
-
-
-def check_packages(dist, attr, value):
-    for pkgname in value:
-        if not re.match(r'\w+(\.\w+)*', pkgname):
-            distutils.log.warn(
-                "WARNING: %r not a valid package name; please use only "
-                ".-separated package names in setup.py", pkgname
-            )
-
-
+ 
+
+def check_packages(dist, attr, value): 
+    for pkgname in value: 
+        if not re.match(r'\w+(\.\w+)*', pkgname): 
+            distutils.log.warn( 
+                "WARNING: %r not a valid package name; please use only " 
+                ".-separated package names in setup.py", pkgname 
+            ) 
+ 
+ 
 _Distribution = get_unpatched(distutils.core.Distribution)
 
 
 class Distribution(_Distribution):
-    """Distribution with support for features, tests, and package data
-
-    This is an enhanced version of 'distutils.dist.Distribution' that
-    effectively adds the following new optional keyword arguments to 'setup()':
-
-     'install_requires' -- a string or sequence of strings specifying project
-        versions that the distribution requires when installed, in the format
-        used by 'pkg_resources.require()'.  They will be installed
-        automatically when the package is installed.  If you wish to use
-        packages that are not available in PyPI, or want to give your users an
-        alternate download location, you can add a 'find_links' option to the
-        '[easy_install]' section of your project's 'setup.cfg' file, and then
-        setuptools will scan the listed web pages for links that satisfy the
-        requirements.
-
-     'extras_require' -- a dictionary mapping names of optional "extras" to the
-        additional requirement(s) that using those extras incurs. For example,
-        this::
-
-            extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])
-
-        indicates that the distribution can optionally provide an extra
-        capability called "reST", but it can only be used if docutils and
-        reSTedit are installed.  If the user installs your package using
-        EasyInstall and requests one of your extras, the corresponding
-        additional requirements will be installed if needed.
-
-     'features' **deprecated** -- a dictionary mapping option names to
-        'setuptools.Feature'
-        objects.  Features are a portion of the distribution that can be
-        included or excluded based on user options, inter-feature dependencies,
-        and availability on the current system.  Excluded features are omitted
-        from all setup commands, including source and binary distributions, so
-        you can create multiple distributions from the same source tree.
-        Feature names should be valid Python identifiers, except that they may
-        contain the '-' (minus) sign.  Features can be included or excluded
-        via the command line options '--with-X' and '--without-X', where 'X' is
-        the name of the feature.  Whether a feature is included by default, and
-        whether you are allowed to control this from the command line, is
-        determined by the Feature object.  See the 'Feature' class for more
-        information.
-
-     'test_suite' -- the name of a test suite to run for the 'test' command.
-        If the user runs 'python setup.py test', the package will be installed,
-        and the named test suite will be run.  The format is the same as
-        would be used on a 'unittest.py' command line.  That is, it is the
-        dotted name of an object to import and call to generate a test suite.
-
-     'package_data' -- a dictionary mapping package names to lists of filenames
-        or globs to use to find data files contained in the named packages.
-        If the dictionary has filenames or globs listed under '""' (the empty
-        string), those names will be searched for in every package, in addition
-        to any names for the specific package.  Data files found using these
-        names/globs will be installed along with the package, in the same
-        location as the package.  Note that globs are allowed to reference
-        the contents of non-package subdirectories, as long as you use '/' as
-        a path separator.  (Globs are automatically converted to
-        platform-specific paths at runtime.)
-
-    In addition to these new keywords, this class also has several new methods
-    for manipulating the distribution's contents.  For example, the 'include()'
-    and 'exclude()' methods can be thought of as in-place add and subtract
-    commands that add or remove packages, modules, extensions, and so on from
-    the distribution.  They are used by the feature subsystem to configure the
-    distribution for the included and excluded features.
-    """
-
+    """Distribution with support for features, tests, and package data 
+ 
+    This is an enhanced version of 'distutils.dist.Distribution' that 
+    effectively adds the following new optional keyword arguments to 'setup()': 
+ 
+     'install_requires' -- a string or sequence of strings specifying project 
+        versions that the distribution requires when installed, in the format 
+        used by 'pkg_resources.require()'.  They will be installed 
+        automatically when the package is installed.  If you wish to use 
+        packages that are not available in PyPI, or want to give your users an 
+        alternate download location, you can add a 'find_links' option to the 
+        '[easy_install]' section of your project's 'setup.cfg' file, and then 
+        setuptools will scan the listed web pages for links that satisfy the 
+        requirements. 
+ 
+     'extras_require' -- a dictionary mapping names of optional "extras" to the 
+        additional requirement(s) that using those extras incurs. For example, 
+        this:: 
+ 
+            extras_require = dict(reST = ["docutils>=0.3", "reSTedit"]) 
+ 
+        indicates that the distribution can optionally provide an extra 
+        capability called "reST", but it can only be used if docutils and 
+        reSTedit are installed.  If the user installs your package using 
+        EasyInstall and requests one of your extras, the corresponding 
+        additional requirements will be installed if needed. 
+ 
+     'features' **deprecated** -- a dictionary mapping option names to 
+        'setuptools.Feature' 
+        objects.  Features are a portion of the distribution that can be 
+        included or excluded based on user options, inter-feature dependencies, 
+        and availability on the current system.  Excluded features are omitted 
+        from all setup commands, including source and binary distributions, so 
+        you can create multiple distributions from the same source tree. 
+        Feature names should be valid Python identifiers, except that they may 
+        contain the '-' (minus) sign.  Features can be included or excluded 
+        via the command line options '--with-X' and '--without-X', where 'X' is 
+        the name of the feature.  Whether a feature is included by default, and 
+        whether you are allowed to control this from the command line, is 
+        determined by the Feature object.  See the 'Feature' class for more 
+        information. 
+ 
+     'test_suite' -- the name of a test suite to run for the 'test' command. 
+        If the user runs 'python setup.py test', the package will be installed, 
+        and the named test suite will be run.  The format is the same as 
+        would be used on a 'unittest.py' command line.  That is, it is the 
+        dotted name of an object to import and call to generate a test suite. 
+ 
+     'package_data' -- a dictionary mapping package names to lists of filenames 
+        or globs to use to find data files contained in the named packages. 
+        If the dictionary has filenames or globs listed under '""' (the empty 
+        string), those names will be searched for in every package, in addition 
+        to any names for the specific package.  Data files found using these 
+        names/globs will be installed along with the package, in the same 
+        location as the package.  Note that globs are allowed to reference 
+        the contents of non-package subdirectories, as long as you use '/' as 
+        a path separator.  (Globs are automatically converted to 
+        platform-specific paths at runtime.) 
+ 
+    In addition to these new keywords, this class also has several new methods 
+    for manipulating the distribution's contents.  For example, the 'include()' 
+    and 'exclude()' methods can be thought of as in-place add and subtract 
+    commands that add or remove packages, modules, extensions, and so on from 
+    the distribution.  They are used by the feature subsystem to configure the 
+    distribution for the included and excluded features. 
+    """ 
+ 
     _DISTUTILS_UNSUPPORTED_METADATA = {
         'long_description_content_type': None,
         'project_urls': dict,
@@ -412,38 +412,38 @@ class Distribution(_Distribution):
         'license_files': ordered_set.OrderedSet,
     }
 
-    _patched_dist = None
-
-    def patch_missing_pkg_info(self, attrs):
-        # Fake up a replacement for the data that would normally come from
-        # PKG-INFO, but which might not yet be built if this is a fresh
-        # checkout.
-        #
-        if not attrs or 'name' not in attrs or 'version' not in attrs:
-            return
-        key = pkg_resources.safe_name(str(attrs['name'])).lower()
-        dist = pkg_resources.working_set.by_key.get(key)
-        if dist is not None and not dist.has_metadata('PKG-INFO'):
-            dist._version = pkg_resources.safe_version(str(attrs['version']))
-            self._patched_dist = dist
-
-    def __init__(self, attrs=None):
-        have_package_data = hasattr(self, "package_data")
-        if not have_package_data:
-            self.package_data = {}
+    _patched_dist = None 
+ 
+    def patch_missing_pkg_info(self, attrs): 
+        # Fake up a replacement for the data that would normally come from 
+        # PKG-INFO, but which might not yet be built if this is a fresh 
+        # checkout. 
+        # 
+        if not attrs or 'name' not in attrs or 'version' not in attrs: 
+            return 
+        key = pkg_resources.safe_name(str(attrs['name'])).lower() 
+        dist = pkg_resources.working_set.by_key.get(key) 
+        if dist is not None and not dist.has_metadata('PKG-INFO'): 
+            dist._version = pkg_resources.safe_version(str(attrs['version'])) 
+            self._patched_dist = dist 
+ 
+    def __init__(self, attrs=None): 
+        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:
-            Feature.warn_deprecated()
-        self.require_features = []
-        self.features = {}
-        self.dist_files = []
+            Feature.warn_deprecated() 
+        self.require_features = [] 
+        self.features = {} 
+        self.dist_files = [] 
         # Filter-out setuptools' specific options.
         self.src_root = attrs.pop("src_root", None)
-        self.patch_missing_pkg_info(attrs)
+        self.patch_missing_pkg_info(attrs) 
         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)
+        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
@@ -461,29 +461,29 @@ class Distribution(_Distribution):
                 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)
-
-        if self.metadata.version is not None:
-            try:
-                ver = packaging.version.Version(self.metadata.version)
-                normalized_version = str(ver)
-                if self.metadata.version != normalized_version:
-                    warnings.warn(
-                        "Normalizing '%s' to '%s'" % (
-                            self.metadata.version,
-                            normalized_version,
-                        )
-                    )
-                    self.metadata.version = normalized_version
-            except (packaging.version.InvalidVersion, TypeError):
-                warnings.warn(
-                    "The version specified (%r) is an invalid version, this "
-                    "may not work as expected with newer versions of "
-                    "setuptools, pip, and PyPI. Please see PEP 440 for more "
-                    "details." % self.metadata.version
-                )
+        if isinstance(self.metadata.version, numbers.Number): 
+            # Some people apparently take "version number" too literally :) 
+            self.metadata.version = str(self.metadata.version) 
+ 
+        if self.metadata.version is not None: 
+            try: 
+                ver = packaging.version.Version(self.metadata.version) 
+                normalized_version = str(ver) 
+                if self.metadata.version != normalized_version: 
+                    warnings.warn( 
+                        "Normalizing '%s' to '%s'" % ( 
+                            self.metadata.version, 
+                            normalized_version, 
+                        ) 
+                    ) 
+                    self.metadata.version = normalized_version 
+            except (packaging.version.InvalidVersion, TypeError): 
+                warnings.warn( 
+                    "The version specified (%r) is an invalid version, this " 
+                    "may not work as expected with newer versions of " 
+                    "setuptools, pip, and PyPI. Please see PEP 440 for more " 
+                    "details." % self.metadata.version 
+                ) 
         self._finalize_requires()
 
     def _finalize_requires(self):
@@ -493,7 +493,7 @@ class Distribution(_Distribution):
         """
         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
@@ -702,29 +702,29 @@ class Distribution(_Distribution):
                             ignore_option_errors=ignore_option_errors)
         self._finalize_requires()
 
-    def parse_command_line(self):
-        """Process features after parsing command line options"""
-        result = _Distribution.parse_command_line(self)
-        if self.features:
-            self._finalize_features()
-        return result
-
+    def parse_command_line(self): 
+        """Process features after parsing command line options""" 
+        result = _Distribution.parse_command_line(self) 
+        if self.features: 
+            self._finalize_features() 
+        return result 
+ 
     def _feature_attrname(self, name):
-        """Convert feature name to corresponding option attribute name"""
+        """Convert feature name to corresponding option attribute name""" 
         return 'with_' + name.replace('-', '_')
-
-    def fetch_build_eggs(self, requires):
-        """Resolve pre-setup requirements"""
-        resolved_dists = pkg_resources.working_set.resolve(
-            pkg_resources.parse_requirements(requires),
-            installer=self.fetch_build_egg,
-            replace_conflicting=True,
-        )
-        for dist in resolved_dists:
-            pkg_resources.working_set.add(dist, replace=True)
+ 
+    def fetch_build_eggs(self, requires): 
+        """Resolve pre-setup requirements""" 
+        resolved_dists = pkg_resources.working_set.resolve( 
+            pkg_resources.parse_requirements(requires), 
+            installer=self.fetch_build_egg, 
+            replace_conflicting=True, 
+        ) 
+        for dist in resolved_dists: 
+            pkg_resources.working_set.add(dist, replace=True) 
         return resolved_dists
-
-    def finalize_options(self):
+ 
+    def finalize_options(self): 
         """
         Allow plugins to apply arbitrary operations to the
         distribution. Each hook may optionally define a 'order'
@@ -732,7 +732,7 @@ class Distribution(_Distribution):
         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))
@@ -740,533 +740,533 @@ class Distribution(_Distribution):
             ep(self)
 
     def _finalize_setup_keywords(self):
-        for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
+        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)
+            if value is not None: 
+                ep.require(installer=self.fetch_build_egg) 
+                ep.load()(self, ep.name, value) 
 
     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
+        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
             ]
-        else:
-            self.convert_2to3_doctests = []
-
-    def get_egg_cache_dir(self):
-        egg_cache_dir = os.path.join(os.curdir, '.eggs')
-        if not os.path.exists(egg_cache_dir):
-            os.mkdir(egg_cache_dir)
-            windows_support.hide_file(egg_cache_dir)
-            readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
-            with open(readme_txt_filename, 'w') as f:
-                f.write('This directory contains eggs that were downloaded '
-                        'by setuptools to build, test, and run plug-ins.\n\n')
-                f.write('This directory caches those eggs to prevent '
-                        'repeated downloads.\n\n')
-                f.write('However, it is safe to delete this directory.\n\n')
-
-        return egg_cache_dir
-
-    def fetch_build_egg(self, req):
-        """Fetch an egg needed for building"""
+        else: 
+            self.convert_2to3_doctests = [] 
+ 
+    def get_egg_cache_dir(self): 
+        egg_cache_dir = os.path.join(os.curdir, '.eggs') 
+        if not os.path.exists(egg_cache_dir): 
+            os.mkdir(egg_cache_dir) 
+            windows_support.hide_file(egg_cache_dir) 
+            readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt') 
+            with open(readme_txt_filename, 'w') as f: 
+                f.write('This directory contains eggs that were downloaded ' 
+                        'by setuptools to build, test, and run plug-ins.\n\n') 
+                f.write('This directory caches those eggs to prevent ' 
+                        'repeated downloads.\n\n') 
+                f.write('However, it is safe to delete this directory.\n\n') 
+ 
+        return egg_cache_dir 
+ 
+    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)
-
+ 
     def _finalize_feature_opts(self):
-        """Add --with-X/--without-X options based on optional features"""
-
+        """Add --with-X/--without-X options based on optional features""" 
+ 
         if not self.features:
             return
 
-        go = []
-        no = self.negative_opt.copy()
-
+        go = [] 
+        no = self.negative_opt.copy() 
+ 
         for name, feature in self.features.items():
             self._set_feature(name, None)
-            feature.validate(self)
-
-            if feature.optional:
-                descr = feature.description
-                incdef = ' (default)'
+            feature.validate(self) 
+ 
+            if feature.optional: 
+                descr = feature.description 
+                incdef = ' (default)' 
                 excdef = ''
-                if not feature.include_by_default():
-                    excdef, incdef = incdef, excdef
-
+                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)
                 no['without-' + name] = 'with-' + name
-
-        self.global_options = self.feature_options = go + self.global_options
-        self.negative_opt = self.feature_negopt = no
-
-    def _finalize_features(self):
-        """Add/remove features and resolve dependencies between them"""
-
-        # First, flag all the enabled items (and thus their dependencies)
+ 
+        self.global_options = self.feature_options = go + self.global_options 
+        self.negative_opt = self.feature_negopt = no 
+ 
+    def _finalize_features(self): 
+        """Add/remove features and resolve dependencies between them""" 
+ 
+        # First, flag all the enabled items (and thus their dependencies) 
         for name, feature in self.features.items():
-            enabled = self.feature_is_included(name)
-            if enabled or (enabled is None and feature.include_by_default()):
-                feature.include_in(self)
+            enabled = self.feature_is_included(name) 
+            if enabled or (enabled is None and feature.include_by_default()): 
+                feature.include_in(self) 
                 self._set_feature(name, 1)
-
-        # Then disable the rest, so that off-by-default features don't
-        # get flagged as errors when they're required by an enabled feature
+ 
+        # Then disable the rest, so that off-by-default features don't 
+        # get flagged as errors when they're required by an enabled feature 
         for name, feature in self.features.items():
-            if not self.feature_is_included(name):
-                feature.exclude_from(self)
+            if not self.feature_is_included(name): 
+                feature.exclude_from(self) 
                 self._set_feature(name, 0)
-
-    def get_command_class(self, command):
-        """Pluggable version of get_command_class()"""
-        if command in self.cmdclass:
-            return self.cmdclass[command]
-
+ 
+    def get_command_class(self, command): 
+        """Pluggable version of get_command_class()""" 
+        if command in self.cmdclass: 
+            return self.cmdclass[command] 
+ 
         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
-        else:
-            return _Distribution.get_command_class(self, command)
-
-    def print_commands(self):
-        for ep in pkg_resources.iter_entry_points('distutils.commands'):
-            if ep.name not in self.cmdclass:
-                # don't require extras as the commands won't be invoked
-                cmdclass = ep.resolve()
-                self.cmdclass[ep.name] = cmdclass
-        return _Distribution.print_commands(self)
-
-    def get_command_list(self):
-        for ep in pkg_resources.iter_entry_points('distutils.commands'):
-            if ep.name not in self.cmdclass:
-                # don't require extras as the commands won't be invoked
-                cmdclass = ep.resolve()
-                self.cmdclass[ep.name] = cmdclass
-        return _Distribution.get_command_list(self)
-
+            ep.require(installer=self.fetch_build_egg) 
+            self.cmdclass[command] = cmdclass = ep.load() 
+            return cmdclass 
+        else: 
+            return _Distribution.get_command_class(self, command) 
+ 
+    def print_commands(self): 
+        for ep in pkg_resources.iter_entry_points('distutils.commands'): 
+            if ep.name not in self.cmdclass: 
+                # don't require extras as the commands won't be invoked 
+                cmdclass = ep.resolve() 
+                self.cmdclass[ep.name] = cmdclass 
+        return _Distribution.print_commands(self) 
+ 
+    def get_command_list(self): 
+        for ep in pkg_resources.iter_entry_points('distutils.commands'): 
+            if ep.name not in self.cmdclass: 
+                # don't require extras as the commands won't be invoked 
+                cmdclass = ep.resolve() 
+                self.cmdclass[ep.name] = cmdclass 
+        return _Distribution.get_command_list(self) 
+ 
     def _set_feature(self, name, status):
-        """Set feature's inclusion status"""
+        """Set feature's inclusion status""" 
         setattr(self, self._feature_attrname(name), status)
-
+ 
     def feature_is_included(self, name):
-        """Return 1 if feature is included, 0 if excluded, 'None' if unknown"""
+        """Return 1 if feature is included, 0 if excluded, 'None' if unknown""" 
         return getattr(self, self._feature_attrname(name))
-
+ 
     def include_feature(self, name):
-        """Request inclusion of feature named 'name'"""
-
+        """Request inclusion of feature named 'name'""" 
+ 
         if self.feature_is_included(name) == 0:
-            descr = self.features[name].description
-            raise DistutilsOptionError(
-                descr + " is required, but was excluded or is not available"
-            )
-        self.features[name].include_in(self)
+            descr = self.features[name].description 
+            raise DistutilsOptionError( 
+                descr + " is required, but was excluded or is not available" 
+            ) 
+        self.features[name].include_in(self) 
         self._set_feature(name, 1)
-
+ 
     def include(self, **attrs):
-        """Add items to distribution that are named in keyword arguments
-
+        """Add items to distribution that are named in keyword arguments 
+ 
         For example, 'dist.include(py_modules=["x"])' would add 'x' to
-        the distribution's 'py_modules' attribute, if it was not already
-        there.
-
-        Currently, this method only supports inclusion for attributes that are
-        lists or tuples.  If you need to add support for adding to other
-        attributes in this or a subclass, you can add an '_include_X' method,
-        where 'X' is the name of the attribute.  The method will be called with
-        the value passed to 'include()'.  So, 'dist.include(foo={"bar":"baz"})'
-        will try to call 'dist._include_foo({"bar":"baz"})', which can then
-        handle whatever special inclusion logic is needed.
-        """
+        the distribution's 'py_modules' attribute, if it was not already 
+        there. 
+ 
+        Currently, this method only supports inclusion for attributes that are 
+        lists or tuples.  If you need to add support for adding to other 
+        attributes in this or a subclass, you can add an '_include_X' method, 
+        where 'X' is the name of the attribute.  The method will be called with 
+        the value passed to 'include()'.  So, 'dist.include(foo={"bar":"baz"})' 
+        will try to call 'dist._include_foo({"bar":"baz"})', which can then 
+        handle whatever special inclusion logic is needed. 
+        """ 
         for k, v in attrs.items():
             include = getattr(self, '_include_' + k, None)
-            if include:
-                include(v)
-            else:
+            if include: 
+                include(v) 
+            else: 
                 self._include_misc(k, v)
-
+ 
     def exclude_package(self, package):
-        """Remove packages, modules, and extensions in named package"""
-
+        """Remove packages, modules, and extensions in named package""" 
+ 
         pfx = package + '.'
-        if self.packages:
-            self.packages = [
-                p for p in self.packages
+        if self.packages: 
+            self.packages = [ 
+                p for p in self.packages 
                 if p != package and not p.startswith(pfx)
-            ]
-
-        if self.py_modules:
-            self.py_modules = [
-                p for p in self.py_modules
+            ] 
+ 
+        if self.py_modules: 
+            self.py_modules = [ 
+                p for p in self.py_modules 
                 if p != package and not p.startswith(pfx)
-            ]
-
-        if self.ext_modules:
-            self.ext_modules = [
-                p for p in self.ext_modules
+            ] 
+ 
+        if self.ext_modules: 
+            self.ext_modules = [ 
+                p for p in self.ext_modules 
                 if p.name != package and not p.name.startswith(pfx)
-            ]
-
+            ] 
+ 
     def has_contents_for(self, package):
-        """Return true if 'exclude_package(package)' would do something"""
-
+        """Return true if 'exclude_package(package)' would do something""" 
+ 
         pfx = package + '.'
-
-        for p in self.iter_distribution_names():
+ 
+        for p in self.iter_distribution_names(): 
             if p == package or p.startswith(pfx):
-                return True
-
+                return True 
+ 
     def _exclude_misc(self, name, value):
-        """Handle 'exclude()' for list/tuple attrs without a special handler"""
+        """Handle 'exclude()' for list/tuple attrs without a special handler""" 
         if not isinstance(value, sequence):
-            raise DistutilsSetupError(
-                "%s: setting must be a list or tuple (%r)" % (name, value)
-            )
-        try:
+            raise DistutilsSetupError( 
+                "%s: setting must be a list or tuple (%r)" % (name, value) 
+            ) 
+        try: 
             old = getattr(self, name)
-        except AttributeError:
-            raise DistutilsSetupError(
-                "%s: No such distribution setting" % name
-            )
+        except AttributeError: 
+            raise DistutilsSetupError( 
+                "%s: No such distribution setting" % name 
+            ) 
         if old is not None and not isinstance(old, sequence):
-            raise DistutilsSetupError(
+            raise DistutilsSetupError( 
                 name + ": this setting cannot be changed via include/exclude"
-            )
-        elif old:
+            ) 
+        elif old: 
             setattr(self, name, [item for item in old if item not in value])
-
+ 
     def _include_misc(self, name, value):
-        """Handle 'include()' for list/tuple attrs without a special handler"""
-
+        """Handle 'include()' for list/tuple attrs without a special handler""" 
+ 
         if not isinstance(value, sequence):
-            raise DistutilsSetupError(
-                "%s: setting must be a list (%r)" % (name, value)
-            )
-        try:
+            raise DistutilsSetupError( 
+                "%s: setting must be a list (%r)" % (name, value) 
+            ) 
+        try: 
             old = getattr(self, name)
-        except AttributeError:
-            raise DistutilsSetupError(
-                "%s: No such distribution setting" % name
-            )
-        if old is None:
+        except AttributeError: 
+            raise DistutilsSetupError( 
+                "%s: No such distribution setting" % name 
+            ) 
+        if old is None: 
             setattr(self, name, value)
         elif not isinstance(old, sequence):
-            raise DistutilsSetupError(
+            raise DistutilsSetupError( 
                 name + ": this setting cannot be changed via include/exclude"
-            )
-        else:
+            ) 
+        else: 
             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
-
-        For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
-        the distribution's 'py_modules' attribute.  Excluding packages uses
-        the 'exclude_package()' method, so all of the package's contained
-        packages, modules, and extensions are also excluded.
-
-        Currently, this method only supports exclusion from attributes that are
-        lists or tuples.  If you need to add support for excluding from other
-        attributes in this or a subclass, you can add an '_exclude_X' method,
-        where 'X' is the name of the attribute.  The method will be called with
-        the value passed to 'exclude()'.  So, 'dist.exclude(foo={"bar":"baz"})'
-        will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
-        handle whatever special exclusion logic is needed.
-        """
+        """Remove items from distribution that are named in keyword arguments 
+ 
+        For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from 
+        the distribution's 'py_modules' attribute.  Excluding packages uses 
+        the 'exclude_package()' method, so all of the package's contained 
+        packages, modules, and extensions are also excluded. 
+ 
+        Currently, this method only supports exclusion from attributes that are 
+        lists or tuples.  If you need to add support for excluding from other 
+        attributes in this or a subclass, you can add an '_exclude_X' method, 
+        where 'X' is the name of the attribute.  The method will be called with 
+        the value passed to 'exclude()'.  So, 'dist.exclude(foo={"bar":"baz"})' 
+        will try to call 'dist._exclude_foo({"bar":"baz"})', which can then 
+        handle whatever special exclusion logic is needed. 
+        """ 
         for k, v in attrs.items():
             exclude = getattr(self, '_exclude_' + k, None)
-            if exclude:
-                exclude(v)
-            else:
+            if exclude: 
+                exclude(v) 
+            else: 
                 self._exclude_misc(k, v)
-
+ 
     def _exclude_packages(self, packages):
         if not isinstance(packages, sequence):
-            raise DistutilsSetupError(
-                "packages: setting must be a list or tuple (%r)" % (packages,)
-            )
-        list(map(self.exclude_package, packages))
-
-    def _parse_command_opts(self, parser, args):
-        # Remove --with-X/--without-X options when processing command args
-        self.global_options = self.__class__.global_options
-        self.negative_opt = self.__class__.negative_opt
-
-        # First, expand any aliases
-        command = args[0]
-        aliases = self.get_option_dict('aliases')
-        while command in aliases:
+            raise DistutilsSetupError( 
+                "packages: setting must be a list or tuple (%r)" % (packages,) 
+            ) 
+        list(map(self.exclude_package, packages)) 
+ 
+    def _parse_command_opts(self, parser, args): 
+        # Remove --with-X/--without-X options when processing command args 
+        self.global_options = self.__class__.global_options 
+        self.negative_opt = self.__class__.negative_opt 
+ 
+        # First, expand any aliases 
+        command = args[0] 
+        aliases = self.get_option_dict('aliases') 
+        while command in aliases: 
             src, alias = aliases[command]
             del aliases[command]  # ensure each alias can expand only once!
-            import shlex
+            import shlex 
             args[:1] = shlex.split(alias, True)
-            command = args[0]
-
-        nargs = _Distribution._parse_command_opts(self, parser, args)
-
-        # Handle commands that want to consume all remaining arguments
-        cmd_class = self.get_command_class(command)
+            command = args[0] 
+ 
+        nargs = _Distribution._parse_command_opts(self, parser, args) 
+ 
+        # Handle commands that want to consume all remaining arguments 
+        cmd_class = self.get_command_class(command) 
         if getattr(cmd_class, 'command_consumes_arguments', None):
-            self.get_option_dict(command)['args'] = ("command line", nargs)
-            if nargs is not None:
-                return []
-
-        return nargs
-
-    def get_cmdline_options(self):
-        """Return a '{cmd: {opt:val}}' map of all command-line options
-
-        Option names are all long, but do not include the leading '--', and
-        contain dashes rather than underscores.  If the option doesn't take
-        an argument (e.g. '--quiet'), the 'val' is 'None'.
-
-        Note that options provided by config files are intentionally excluded.
-        """
-
-        d = {}
-
+            self.get_option_dict(command)['args'] = ("command line", nargs) 
+            if nargs is not None: 
+                return [] 
+ 
+        return nargs 
+ 
+    def get_cmdline_options(self): 
+        """Return a '{cmd: {opt:val}}' map of all command-line options 
+ 
+        Option names are all long, but do not include the leading '--', and 
+        contain dashes rather than underscores.  If the option doesn't take 
+        an argument (e.g. '--quiet'), the 'val' is 'None'. 
+ 
+        Note that options provided by config files are intentionally excluded. 
+        """ 
+ 
+        d = {} 
+ 
         for cmd, opts in self.command_options.items():
-
+ 
             for opt, (src, val) in opts.items():
-
-                if src != "command line":
-                    continue
-
+ 
+                if src != "command line": 
+                    continue 
+ 
                 opt = opt.replace('_', '-')
-
+ 
                 if val == 0:
-                    cmdobj = self.get_command_obj(cmd)
-                    neg_opt = self.negative_opt.copy()
+                    cmdobj = self.get_command_obj(cmd) 
+                    neg_opt = self.negative_opt.copy() 
                     neg_opt.update(getattr(cmdobj, 'negative_opt', {}))
                     for neg, pos in neg_opt.items():
                         if pos == opt:
                             opt = neg
                             val = None
-                            break
-                    else:
-                        raise AssertionError("Shouldn't be able to get here")
-
+                            break 
+                    else: 
+                        raise AssertionError("Shouldn't be able to get here") 
+ 
                 elif val == 1:
-                    val = None
-
+                    val = None 
+ 
                 d.setdefault(cmd, {})[opt] = val
-
-        return d
-
-    def iter_distribution_names(self):
-        """Yield all packages, modules, and extension names in distribution"""
-
-        for pkg in self.packages or ():
-            yield pkg
-
-        for module in self.py_modules or ():
-            yield module
-
-        for ext in self.ext_modules or ():
+ 
+        return d 
+ 
+    def iter_distribution_names(self): 
+        """Yield all packages, modules, and extension names in distribution""" 
+ 
+        for pkg in self.packages or (): 
+            yield pkg 
+ 
+        for module in self.py_modules or (): 
+            yield module 
+ 
+        for ext in self.ext_modules or (): 
             if isinstance(ext, tuple):
-                name, buildinfo = ext
-            else:
-                name = ext.name
-            if name.endswith('module'):
-                name = name[:-6]
-            yield name
-
-    def handle_display_options(self, option_order):
-        """If there were any non-global "display-only" options
-        (--help-commands or the metadata display options) on the command
-        line, display the requested info and return true; else return
-        false.
-        """
-        import sys
-
-        if six.PY2 or self.help_commands:
-            return _Distribution.handle_display_options(self, option_order)
-
-        # Stdout may be StringIO (e.g. in tests)
-        if not isinstance(sys.stdout, io.TextIOWrapper):
-            return _Distribution.handle_display_options(self, option_order)
-
-        # Don't wrap stdout if utf-8 is already the encoding. Provides
-        #  workaround for #334.
-        if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
-            return _Distribution.handle_display_options(self, option_order)
-
-        # Print metadata in UTF-8 no matter the platform
-        encoding = sys.stdout.encoding
-        errors = sys.stdout.errors
-        newline = sys.platform != 'win32' and '\n' or None
-        line_buffering = sys.stdout.line_buffering
-
-        sys.stdout = io.TextIOWrapper(
-            sys.stdout.detach(), 'utf-8', errors, newline, line_buffering)
-        try:
-            return _Distribution.handle_display_options(self, option_order)
-        finally:
-            sys.stdout = io.TextIOWrapper(
-                sys.stdout.detach(), encoding, errors, newline, line_buffering)
-
-
-class Feature:
-    """
-    **deprecated** -- The `Feature` facility was never completely implemented
-    or supported, `has reported issues
+                name, buildinfo = ext 
+            else: 
+                name = ext.name 
+            if name.endswith('module'): 
+                name = name[:-6] 
+            yield name 
+ 
+    def handle_display_options(self, option_order): 
+        """If there were any non-global "display-only" options 
+        (--help-commands or the metadata display options) on the command 
+        line, display the requested info and return true; else return 
+        false. 
+        """ 
+        import sys 
+ 
+        if six.PY2 or self.help_commands: 
+            return _Distribution.handle_display_options(self, option_order) 
+ 
+        # Stdout may be StringIO (e.g. in tests) 
+        if not isinstance(sys.stdout, io.TextIOWrapper): 
+            return _Distribution.handle_display_options(self, option_order) 
+ 
+        # Don't wrap stdout if utf-8 is already the encoding. Provides 
+        #  workaround for #334. 
+        if sys.stdout.encoding.lower() in ('utf-8', 'utf8'): 
+            return _Distribution.handle_display_options(self, option_order) 
+ 
+        # Print metadata in UTF-8 no matter the platform 
+        encoding = sys.stdout.encoding 
+        errors = sys.stdout.errors 
+        newline = sys.platform != 'win32' and '\n' or None 
+        line_buffering = sys.stdout.line_buffering 
+ 
+        sys.stdout = io.TextIOWrapper( 
+            sys.stdout.detach(), 'utf-8', errors, newline, line_buffering) 
+        try: 
+            return _Distribution.handle_display_options(self, option_order) 
+        finally: 
+            sys.stdout = io.TextIOWrapper( 
+                sys.stdout.detach(), encoding, errors, newline, line_buffering) 
+ 
+ 
+class Feature: 
+    """ 
+    **deprecated** -- The `Feature` facility was never completely implemented 
+    or supported, `has reported issues 
     <https://github.com/pypa/setuptools/issues/58>`_ and will be removed in
-    a future version.
-
-    A subset of the distribution that can be excluded if unneeded/wanted
-
-    Features are created using these keyword arguments:
-
-      'description' -- a short, human readable description of the feature, to
-         be used in error messages, and option help messages.
-
-      'standard' -- if true, the feature is included by default if it is
-         available on the current system.  Otherwise, the feature is only
-         included if requested via a command line '--with-X' option, or if
-         another included feature requires it.  The default setting is 'False'.
-
-      'available' -- if true, the feature is available for installation on the
-         current system.  The default setting is 'True'.
-
-      'optional' -- if true, the feature's inclusion can be controlled from the
-         command line, using the '--with-X' or '--without-X' options.  If
-         false, the feature's inclusion status is determined automatically,
-         based on 'availabile', 'standard', and whether any other feature
-         requires it.  The default setting is 'True'.
-
-      'require_features' -- a string or sequence of strings naming features
-         that should also be included if this feature is included.  Defaults to
-         empty list.  May also contain 'Require' objects that should be
-         added/removed from the distribution.
-
-      'remove' -- a string or list of strings naming packages to be removed
-         from the distribution if this feature is *not* included.  If the
-         feature *is* included, this argument is ignored.  This argument exists
-         to support removing features that "crosscut" a distribution, such as
-         defining a 'tests' feature that removes all the 'tests' subpackages
-         provided by other features.  The default for this argument is an empty
-         list.  (Note: the named package(s) or modules must exist in the base
-         distribution when the 'setup()' function is initially called.)
-
-      other keywords -- any other keyword arguments are saved, and passed to
-         the distribution's 'include()' and 'exclude()' methods when the
-         feature is included or excluded, respectively.  So, for example, you
-         could pass 'packages=["a","b"]' to cause packages 'a' and 'b' to be
-         added or removed from the distribution as appropriate.
-
-    A feature must include at least one 'requires', 'remove', or other
-    keyword argument.  Otherwise, it can't affect the distribution in any way.
-    Note also that you can subclass 'Feature' to create your own specialized
-    feature types that modify the distribution in other ways when included or
-    excluded.  See the docstrings for the various methods here for more detail.
-    Aside from the methods, the only feature attributes that distributions look
-    at are 'description' and 'optional'.
-    """
-
-    @staticmethod
-    def warn_deprecated():
+    a future version. 
+ 
+    A subset of the distribution that can be excluded if unneeded/wanted 
+ 
+    Features are created using these keyword arguments: 
+ 
+      'description' -- a short, human readable description of the feature, to 
+         be used in error messages, and option help messages. 
+ 
+      'standard' -- if true, the feature is included by default if it is 
+         available on the current system.  Otherwise, the feature is only 
+         included if requested via a command line '--with-X' option, or if 
+         another included feature requires it.  The default setting is 'False'. 
+ 
+      'available' -- if true, the feature is available for installation on the 
+         current system.  The default setting is 'True'. 
+ 
+      'optional' -- if true, the feature's inclusion can be controlled from the 
+         command line, using the '--with-X' or '--without-X' options.  If 
+         false, the feature's inclusion status is determined automatically, 
+         based on 'availabile', 'standard', and whether any other feature 
+         requires it.  The default setting is 'True'. 
+ 
+      'require_features' -- a string or sequence of strings naming features 
+         that should also be included if this feature is included.  Defaults to 
+         empty list.  May also contain 'Require' objects that should be 
+         added/removed from the distribution. 
+ 
+      'remove' -- a string or list of strings naming packages to be removed 
+         from the distribution if this feature is *not* included.  If the 
+         feature *is* included, this argument is ignored.  This argument exists 
+         to support removing features that "crosscut" a distribution, such as 
+         defining a 'tests' feature that removes all the 'tests' subpackages 
+         provided by other features.  The default for this argument is an empty 
+         list.  (Note: the named package(s) or modules must exist in the base 
+         distribution when the 'setup()' function is initially called.) 
+ 
+      other keywords -- any other keyword arguments are saved, and passed to 
+         the distribution's 'include()' and 'exclude()' methods when the 
+         feature is included or excluded, respectively.  So, for example, you 
+         could pass 'packages=["a","b"]' to cause packages 'a' and 'b' to be 
+         added or removed from the distribution as appropriate. 
+ 
+    A feature must include at least one 'requires', 'remove', or other 
+    keyword argument.  Otherwise, it can't affect the distribution in any way. 
+    Note also that you can subclass 'Feature' to create your own specialized 
+    feature types that modify the distribution in other ways when included or 
+    excluded.  See the docstrings for the various methods here for more detail. 
+    Aside from the methods, the only feature attributes that distributions look 
+    at are 'description' and 'optional'. 
+    """ 
+ 
+    @staticmethod 
+    def warn_deprecated(): 
         msg = (
-            "Features are deprecated and will be removed in a future "
+            "Features are deprecated and will be removed in a future " 
             "version. See https://github.com/pypa/setuptools/issues/65."
-        )
+        ) 
         warnings.warn(msg, DistDeprecationWarning, stacklevel=3)
-
+ 
     def __init__(
             self, description, standard=False, available=True,
-            optional=True, require_features=(), remove=(), **extras):
-        self.warn_deprecated()
-
-        self.description = description
-        self.standard = standard
-        self.available = available
-        self.optional = optional
+            optional=True, require_features=(), remove=(), **extras): 
+        self.warn_deprecated() 
+ 
+        self.description = description 
+        self.standard = standard 
+        self.available = available 
+        self.optional = optional 
         if isinstance(require_features, (str, Require)):
-            require_features = require_features,
-
-        self.require_features = [
+            require_features = require_features, 
+ 
+        self.require_features = [ 
             r for r in require_features if isinstance(r, str)
-        ]
+        ] 
         er = [r for r in require_features if not isinstance(r, str)]
         if er:
             extras['require_features'] = er
-
+ 
         if isinstance(remove, str):
-            remove = remove,
-        self.remove = remove
-        self.extras = extras
-
-        if not remove and not require_features and not extras:
-            raise DistutilsSetupError(
+            remove = remove, 
+        self.remove = remove 
+        self.extras = extras 
+ 
+        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."
-            )
-
-    def include_by_default(self):
-        """Should this feature be included by default?"""
-        return self.available and self.standard
-
+            ) 
+ 
+    def include_by_default(self): 
+        """Should this feature be included by default?""" 
+        return self.available and self.standard 
+ 
     def include_in(self, dist):
-        """Ensure feature and its requirements are included in distribution
-
-        You may override this in a subclass to perform additional operations on
-        the distribution.  Note that this method may be called more than once
-        per feature, and so should be idempotent.
-
-        """
-
-        if not self.available:
-            raise DistutilsPlatformError(
+        """Ensure feature and its requirements are included in distribution 
+ 
+        You may override this in a subclass to perform additional operations on 
+        the distribution.  Note that this method may be called more than once 
+        per feature, and so should be idempotent. 
+ 
+        """ 
+ 
+        if not self.available: 
+            raise DistutilsPlatformError( 
                 self.description + " is required, "
-                "but is not available on this platform"
-            )
-
-        dist.include(**self.extras)
-
-        for f in self.require_features:
-            dist.include_feature(f)
-
+                "but is not available on this platform" 
+            ) 
+ 
+        dist.include(**self.extras) 
+ 
+        for f in self.require_features: 
+            dist.include_feature(f) 
+ 
     def exclude_from(self, dist):
-        """Ensure feature is excluded from distribution
-
-        You may override this in a subclass to perform additional operations on
-        the distribution.  This method will be called at most once per
-        feature, and only after all included features have been asked to
-        include themselves.
-        """
-
-        dist.exclude(**self.extras)
-
-        if self.remove:
-            for item in self.remove:
-                dist.exclude_package(item)
-
+        """Ensure feature is excluded from distribution 
+ 
+        You may override this in a subclass to perform additional operations on 
+        the distribution.  This method will be called at most once per 
+        feature, and only after all included features have been asked to 
+        include themselves. 
+        """ 
+ 
+        dist.exclude(**self.extras) 
+ 
+        if self.remove: 
+            for item in self.remove: 
+                dist.exclude_package(item) 
+ 
     def validate(self, dist):
-        """Verify that feature makes sense in context of distribution
-
-        This method is called by the distribution just before it parses its
-        command line.  It checks to ensure that the 'remove' attribute, if any,
-        contains only valid package/module names that are present in the base
-        distribution when 'setup()' is called.  You may override it in a
-        subclass to perform any other required validation of the feature
-        against a target distribution.
-        """
-
-        for item in self.remove:
-            if not dist.has_contents_for(item):
-                raise DistutilsSetupError(
-                    "%s wants to be able to remove %s, but the distribution"
-                    " doesn't contain any packages or modules under %s"
-                    % (self.description, item, item)
-                )
+        """Verify that feature makes sense in context of distribution 
+ 
+        This method is called by the distribution just before it parses its 
+        command line.  It checks to ensure that the 'remove' attribute, if any, 
+        contains only valid package/module names that are present in the base 
+        distribution when 'setup()' is called.  You may override it in a 
+        subclass to perform any other required validation of the feature 
+        against a target distribution. 
+        """ 
+ 
+        for item in self.remove: 
+            if not dist.has_contents_for(item): 
+                raise DistutilsSetupError( 
+                    "%s wants to be able to remove %s, but the distribution" 
+                    " doesn't contain any packages or modules under %s" 
+                    % (self.description, item, item) 
+                ) 
 
 
 class DistDeprecationWarning(SetuptoolsDeprecationWarning):
diff --git a/contrib/python/setuptools/py2/setuptools/extension.py b/contrib/python/setuptools/py2/setuptools/extension.py
index 29468894f8..679c11263d 100644
--- a/contrib/python/setuptools/py2/setuptools/extension.py
+++ b/contrib/python/setuptools/py2/setuptools/extension.py
@@ -1,57 +1,57 @@
-import re
-import functools
-import distutils.core
-import distutils.errors
-import distutils.extension
-
+import re 
+import functools 
+import distutils.core 
+import distutils.errors 
+import distutils.extension 
+ 
 from setuptools.extern.six.moves import map
-
+ 
 from .monkey import get_unpatched
-
-
-def _have_cython():
-    """
-    Return True if Cython can be imported.
-    """
+ 
+ 
+def _have_cython(): 
+    """ 
+    Return True if Cython can be imported. 
+    """ 
     cython_impl = 'Cython.Distutils.build_ext'
-    try:
-        # from (cython_impl) import build_ext
-        __import__(cython_impl, fromlist=['build_ext']).build_ext
-        return True
-    except Exception:
-        pass
-    return False
-
-
-# for compatibility
-have_pyrex = _have_cython
-
+    try: 
+        # from (cython_impl) import build_ext 
+        __import__(cython_impl, fromlist=['build_ext']).build_ext 
+        return True 
+    except Exception: 
+        pass 
+    return False 
+ 
+
+# for compatibility 
+have_pyrex = _have_cython 
+ 
 _Extension = get_unpatched(distutils.core.Extension)
+ 
 
-
-class Extension(_Extension):
-    """Extension that uses '.c' files in place of '.pyx' files"""
-
+class Extension(_Extension): 
+    """Extension that uses '.c' files in place of '.pyx' files""" 
+ 
     def __init__(self, name, sources, *args, **kw):
         # The *args is needed for compatibility as calls may use positional
         # arguments. py_limited_api may be set only via keyword.
         self.py_limited_api = kw.pop("py_limited_api", False)
         _Extension.__init__(self, name, sources, *args, **kw)
 
-    def _convert_pyx_sources_to_lang(self):
-        """
-        Replace sources with .pyx extensions to sources with the target
-        language extension. This mechanism allows language authors to supply
-        pre-converted sources but to prefer the .pyx sources.
-        """
-        if _have_cython():
-            # the build has Cython, so allow it to compile the .pyx files
-            return
-        lang = self.language or ''
-        target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
-        sub = functools.partial(re.sub, '.pyx$', target_ext)
-        self.sources = list(map(sub, self.sources))
-
-
-class Library(Extension):
-    """Just like a regular Extension, but built as a library instead"""
+    def _convert_pyx_sources_to_lang(self): 
+        """ 
+        Replace sources with .pyx extensions to sources with the target 
+        language extension. This mechanism allows language authors to supply 
+        pre-converted sources but to prefer the .pyx sources. 
+        """ 
+        if _have_cython(): 
+            # the build has Cython, so allow it to compile the .pyx files 
+            return 
+        lang = self.language or '' 
+        target_ext = '.cpp' if lang.lower() == 'c++' else '.c' 
+        sub = functools.partial(re.sub, '.pyx$', target_ext) 
+        self.sources = list(map(sub, self.sources)) 
+ 
+
+class Library(Extension): 
+    """Just like a regular Extension, but built as a library instead""" 
diff --git a/contrib/python/setuptools/py2/setuptools/launch.py b/contrib/python/setuptools/py2/setuptools/launch.py
index 308283ea93..8c302e90a1 100644
--- a/contrib/python/setuptools/py2/setuptools/launch.py
+++ b/contrib/python/setuptools/py2/setuptools/launch.py
@@ -1,16 +1,16 @@
-"""
-Launch the Python script on the command line after
-setuptools is bootstrapped via import.
-"""
-
-# Note that setuptools gets imported implicitly by the
-# invocation of this script using python -m setuptools.launch
-
-import tokenize
-import sys
-
-
-def run():
+""" 
+Launch the Python script on the command line after 
+setuptools is bootstrapped via import. 
+""" 
+ 
+# Note that setuptools gets imported implicitly by the 
+# invocation of this script using python -m setuptools.launch 
+ 
+import tokenize 
+import sys 
+ 
+ 
+def run(): 
     """
     Run the script in sys.argv[1] as if it had
     been invoked naturally.
@@ -23,13 +23,13 @@ def run():
         __doc__=None,
     )
     sys.argv[:] = sys.argv[1:]
-
+ 
     open_ = getattr(tokenize, 'open', open)
     script = open_(script_name).read()
     norm_script = script.replace('\\r\\n', '\\n')
     code = compile(norm_script, script_name, 'exec')
     exec(code, namespace)
-
-
-if __name__ == '__main__':
+ 
+ 
+if __name__ == '__main__': 
     run()
diff --git a/contrib/python/setuptools/py2/setuptools/lib2to3_ex.py b/contrib/python/setuptools/py2/setuptools/lib2to3_ex.py
index 4b1a73feb2..b193707807 100644
--- a/contrib/python/setuptools/py2/setuptools/lib2to3_ex.py
+++ b/contrib/python/setuptools/py2/setuptools/lib2to3_ex.py
@@ -1,62 +1,62 @@
-"""
-Customized Mixin2to3 support:
-
- - adds support for converting doctests
-
-
-This module raises an ImportError on Python 2.
-"""
-
-from distutils.util import Mixin2to3 as _Mixin2to3
-from distutils import log
-from lib2to3.refactor import RefactoringTool, get_fixers_from_package
-
-import setuptools
-
-
-class DistutilsRefactoringTool(RefactoringTool):
-    def log_error(self, msg, *args, **kw):
-        log.error(msg, *args)
-
-    def log_message(self, msg, *args):
-        log.info(msg, *args)
-
-    def log_debug(self, msg, *args):
-        log.debug(msg, *args)
-
-
-class Mixin2to3(_Mixin2to3):
+""" 
+Customized Mixin2to3 support: 
+ 
+ - adds support for converting doctests 
+ 
+ 
+This module raises an ImportError on Python 2. 
+""" 
+ 
+from distutils.util import Mixin2to3 as _Mixin2to3 
+from distutils import log 
+from lib2to3.refactor import RefactoringTool, get_fixers_from_package 
+
+import setuptools 
+ 
+
+class DistutilsRefactoringTool(RefactoringTool): 
+    def log_error(self, msg, *args, **kw): 
+        log.error(msg, *args) 
+ 
+    def log_message(self, msg, *args): 
+        log.info(msg, *args) 
+ 
+    def log_debug(self, msg, *args): 
+        log.debug(msg, *args) 
+ 
+
+class Mixin2to3(_Mixin2to3): 
     def run_2to3(self, files, doctests=False):
-        # See of the distribution option has been set, otherwise check the
-        # setuptools default.
-        if self.distribution.use_2to3 is not True:
-            return
-        if not files:
-            return
+        # See of the distribution option has been set, otherwise check the 
+        # setuptools default. 
+        if self.distribution.use_2to3 is not True: 
+            return 
+        if not files: 
+            return 
         log.info("Fixing " + " ".join(files))
-        self.__build_fixer_names()
-        self.__exclude_fixers()
-        if doctests:
-            if setuptools.run_2to3_on_doctests:
-                r = DistutilsRefactoringTool(self.fixer_names)
-                r.refactor(files, write=True, doctests_only=True)
-        else:
-            _Mixin2to3.run_2to3(self, files)
-
-    def __build_fixer_names(self):
+        self.__build_fixer_names() 
+        self.__exclude_fixers() 
+        if doctests: 
+            if setuptools.run_2to3_on_doctests: 
+                r = DistutilsRefactoringTool(self.fixer_names) 
+                r.refactor(files, write=True, doctests_only=True) 
+        else: 
+            _Mixin2to3.run_2to3(self, files) 
+ 
+    def __build_fixer_names(self): 
         if self.fixer_names:
             return
-        self.fixer_names = []
-        for p in setuptools.lib2to3_fixer_packages:
-            self.fixer_names.extend(get_fixers_from_package(p))
-        if self.distribution.use_2to3_fixers is not None:
-            for p in self.distribution.use_2to3_fixers:
-                self.fixer_names.extend(get_fixers_from_package(p))
-
-    def __exclude_fixers(self):
-        excluded_fixers = getattr(self, 'exclude_fixers', [])
-        if self.distribution.use_2to3_exclude_fixers is not None:
-            excluded_fixers.extend(self.distribution.use_2to3_exclude_fixers)
-        for fixer_name in excluded_fixers:
-            if fixer_name in self.fixer_names:
-                self.fixer_names.remove(fixer_name)
+        self.fixer_names = [] 
+        for p in setuptools.lib2to3_fixer_packages: 
+            self.fixer_names.extend(get_fixers_from_package(p)) 
+        if self.distribution.use_2to3_fixers is not None: 
+            for p in self.distribution.use_2to3_fixers: 
+                self.fixer_names.extend(get_fixers_from_package(p)) 
+ 
+    def __exclude_fixers(self): 
+        excluded_fixers = getattr(self, 'exclude_fixers', []) 
+        if self.distribution.use_2to3_exclude_fixers is not None: 
+            excluded_fixers.extend(self.distribution.use_2to3_exclude_fixers) 
+        for fixer_name in excluded_fixers: 
+            if fixer_name in self.fixer_names: 
+                self.fixer_names.remove(fixer_name) 
diff --git a/contrib/python/setuptools/py2/setuptools/package_index.py b/contrib/python/setuptools/py2/setuptools/package_index.py
index f419d47167..38c661dab0 100644
--- a/contrib/python/setuptools/py2/setuptools/package_index.py
+++ b/contrib/python/setuptools/py2/setuptools/package_index.py
@@ -1,50 +1,50 @@
-"""PyPI and direct package downloading"""
-import sys
-import os
-import re
-import shutil
-import socket
-import base64
-import hashlib
-import itertools
+"""PyPI and direct package downloading""" 
+import sys 
+import os 
+import re 
+import shutil 
+import socket 
+import base64 
+import hashlib 
+import itertools 
 import warnings
-from functools import wraps
-
+from functools import wraps 
+ 
 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,
+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,
-)
-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 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
 
 EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.+!]+)$')
 HREF = re.compile(r"""href\s*=\s*['"]?([^'"> ]+)""", re.I)
-PYPI_MD5 = re.compile(
+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>\)'
-)
+) 
 URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):', re.I).match
-EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()
-
-__all__ = [
-    'PackageIndex', 'distros_for_url', 'parse_bdist_wininst',
-    'interpret_distro_name',
-]
-
-_SOCKET_TIMEOUT = 15
-
+EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split() 
+ 
+__all__ = [ 
+    'PackageIndex', 'distros_for_url', 'parse_bdist_wininst', 
+    'interpret_distro_name', 
+] 
+ 
+_SOCKET_TIMEOUT = 15 
+ 
 _tmpl = "setuptools/{setuptools.__version__} Python-urllib/{py_major}"
 user_agent = _tmpl.format(py_major='{}.{}'.format(*sys.version_info), setuptools=setuptools)
 
@@ -58,62 +58,62 @@ def parse_requirement_arg(spec):
         )
 
 
-def parse_bdist_wininst(name):
-    """Return (base,pyversion) or (None,None) for possible .exe name"""
-
-    lower = name.lower()
-    base, py_ver, plat = None, None, None
-
-    if lower.endswith('.exe'):
-        if lower.endswith('.win32.exe'):
-            base = name[:-10]
-            plat = 'win32'
+def parse_bdist_wininst(name): 
+    """Return (base,pyversion) or (None,None) for possible .exe name""" 
+ 
+    lower = name.lower() 
+    base, py_ver, plat = None, None, None 
+ 
+    if lower.endswith('.exe'): 
+        if lower.endswith('.win32.exe'): 
+            base = name[:-10] 
+            plat = 'win32' 
         elif lower.startswith('.win32-py', -16):
-            py_ver = name[-7:-4]
-            base = name[:-16]
-            plat = 'win32'
-        elif lower.endswith('.win-amd64.exe'):
-            base = name[:-14]
-            plat = 'win-amd64'
+            py_ver = name[-7:-4] 
+            base = name[:-16] 
+            plat = 'win32' 
+        elif lower.endswith('.win-amd64.exe'): 
+            base = name[:-14] 
+            plat = 'win-amd64' 
         elif lower.startswith('.win-amd64-py', -20):
-            py_ver = name[-7:-4]
-            base = name[:-20]
-            plat = 'win-amd64'
+            py_ver = name[-7:-4] 
+            base = name[:-20] 
+            plat = 'win-amd64' 
     return base, py_ver, plat
-
-
-def egg_info_for_url(url):
-    parts = urllib.parse.urlparse(url)
-    scheme, server, path, parameters, query, fragment = parts
-    base = urllib.parse.unquote(path.split('/')[-1])
+ 
+ 
+def egg_info_for_url(url): 
+    parts = urllib.parse.urlparse(url) 
+    scheme, server, path, parameters, query, fragment = parts 
+    base = urllib.parse.unquote(path.split('/')[-1]) 
     if server == 'sourceforge.net' and base == 'download':  # XXX Yuck
-        base = urllib.parse.unquote(path.split('/')[-2])
+        base = urllib.parse.unquote(path.split('/')[-2]) 
     if '#' in base:
         base, fragment = base.split('#', 1)
     return base, fragment
+ 
 
-
-def distros_for_url(url, metadata=None):
-    """Yield egg or source distribution objects that might be found at a URL"""
-    base, fragment = egg_info_for_url(url)
+def distros_for_url(url, metadata=None): 
+    """Yield egg or source distribution objects that might be found at a URL""" 
+    base, fragment = egg_info_for_url(url) 
     for dist in distros_for_location(url, base, metadata):
         yield dist
-    if fragment:
-        match = EGG_FRAGMENT.match(fragment)
-        if match:
-            for dist in interpret_distro_name(
+    if fragment: 
+        match = EGG_FRAGMENT.match(fragment) 
+        if match: 
+            for dist in interpret_distro_name( 
                 url, match.group(1), metadata, precedence=CHECKOUT_DIST
-            ):
-                yield dist
-
+            ): 
+                yield dist 
+ 
 
-def distros_for_location(location, basename, metadata=None):
-    """Yield egg or source distribution objects based on basename"""
-    if basename.endswith('.egg.zip'):
+def distros_for_location(location, basename, metadata=None): 
+    """Yield egg or source distribution objects based on basename""" 
+    if basename.endswith('.egg.zip'): 
         basename = basename[:-4]  # strip the .zip
-    if basename.endswith('.egg') and '-' in basename:
-        # only one, unambiguous interpretation
-        return [Distribution.from_location(location, basename, metadata)]
+    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():
@@ -125,508 +125,508 @@ def distros_for_location(location, basename, metadata=None):
             # 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:
-            return interpret_distro_name(
-                location, win_base, metadata, py_ver, BINARY_DIST, platform
-            )
-    # Try source distro extensions (.zip, .tgz, etc.)
-    #
-    for ext in EXTENSIONS:
-        if basename.endswith(ext):
-            basename = basename[:-len(ext)]
-            return interpret_distro_name(location, basename, metadata)
-    return []  # no extension matched
-
-
-def distros_for_filename(filename, metadata=None):
-    """Yield possible egg or source distribution objects based on a filename"""
-    return distros_for_location(
-        normalize_path(filename), os.path.basename(filename), metadata
-    )
-
-
-def interpret_distro_name(
-        location, basename, metadata, py_version=None, precedence=SOURCE_DIST,
-        platform=None
+    if basename.endswith('.exe'): 
+        win_base, py_ver, platform = parse_bdist_wininst(basename) 
+        if win_base is not None: 
+            return interpret_distro_name( 
+                location, win_base, metadata, py_ver, BINARY_DIST, platform 
+            ) 
+    # Try source distro extensions (.zip, .tgz, etc.) 
+    # 
+    for ext in EXTENSIONS: 
+        if basename.endswith(ext): 
+            basename = basename[:-len(ext)] 
+            return interpret_distro_name(location, basename, metadata) 
+    return []  # no extension matched 
+ 
+
+def distros_for_filename(filename, metadata=None): 
+    """Yield possible egg or source distribution objects based on a filename""" 
+    return distros_for_location( 
+        normalize_path(filename), os.path.basename(filename), metadata 
+    ) 
+ 
+ 
+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
-    ``pkg_resources.normalize_path()`` on it before passing it to this
-    routine!
-    """
-    # Generate alternative interpretations of a source distro name
-    # Because some packages are ambiguous as to name/versions split
-    # e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc.
-    # So, we generate each possible interepretation (e.g. "adns, python-1.1.0"
-    # "adns-python, 1.1.0", and "adns-python-1.1.0, no version").  In practice,
-    # the spurious interpretations should be ignored, because in the event
-    # there's also an "adns" package, the spurious "python-1.1.0" version will
-    # compare lower than any numeric version number, and is therefore unlikely
-    # to match a request for it.  It's still a potential problem, though, and
-    # in the long run PyPI and the distutils should go for "safe" names and
-    # versions in distribution archive names (sdist and bdist).
-
-    parts = basename.split('-')
+    """Generate alternative interpretations of a source distro name 
+ 
+    Note: if `location` is a filesystem filename, you should call 
+    ``pkg_resources.normalize_path()`` on it before passing it to this 
+    routine! 
+    """ 
+    # Generate alternative interpretations of a source distro name 
+    # Because some packages are ambiguous as to name/versions split 
+    # e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc. 
+    # So, we generate each possible interepretation (e.g. "adns, python-1.1.0" 
+    # "adns-python, 1.1.0", and "adns-python-1.1.0, no version").  In practice, 
+    # the spurious interpretations should be ignored, because in the event 
+    # there's also an "adns" package, the spurious "python-1.1.0" version will 
+    # compare lower than any numeric version number, and is therefore unlikely 
+    # to match a request for it.  It's still a potential problem, though, and 
+    # in the long run PyPI and the distutils should go for "safe" names and 
+    # versions in distribution archive names (sdist and bdist). 
+ 
+    parts = basename.split('-') 
     if not py_version and any(re.match(r'py\d\.\d$', p) for p in parts[2:]):
-        # it is a bdist_dumb, not an sdist -- bail out
-        return
-
+        # it is a bdist_dumb, not an sdist -- bail out 
+        return 
+ 
     for p in range(1, len(parts) + 1):
-        yield Distribution(
-            location, metadata, '-'.join(parts[:p]), '-'.join(parts[p:]),
+        yield Distribution( 
+            location, metadata, '-'.join(parts[:p]), '-'.join(parts[p:]), 
             py_version=py_version, precedence=precedence,
             platform=platform
-        )
-
-
-# From Python 2.7 docs
-def unique_everseen(iterable, key=None):
-    "List unique elements, preserving order. Remember all elements ever seen."
-    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
-    # unique_everseen('ABBCcAD', str.lower) --> A B C D
-    seen = set()
-    seen_add = seen.add
-    if key is None:
-        for element in six.moves.filterfalse(seen.__contains__, iterable):
-            seen_add(element)
-            yield element
-    else:
-        for element in iterable:
-            k = key(element)
-            if k not in seen:
-                seen_add(k)
-                yield element
-
-
-def unique_values(func):
-    """
-    Wrap a function returning an iterable such that the resulting iterable
-    only ever yields unique items.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return unique_everseen(func(*args, **kwargs))
-
-    return wrapper
-
+        ) 
+ 
+
+# From Python 2.7 docs 
+def unique_everseen(iterable, key=None): 
+    "List unique elements, preserving order. Remember all elements ever seen." 
+    # unique_everseen('AAAABBBCCDAABBB') --> A B C D 
+    # unique_everseen('ABBCcAD', str.lower) --> A B C D 
+    seen = set() 
+    seen_add = seen.add 
+    if key is None: 
+        for element in six.moves.filterfalse(seen.__contains__, iterable): 
+            seen_add(element) 
+            yield element 
+    else: 
+        for element in iterable: 
+            k = key(element) 
+            if k not in seen: 
+                seen_add(k) 
+                yield element 
+ 
+
+def unique_values(func): 
+    """ 
+    Wrap a function returning an iterable such that the resulting iterable 
+    only ever yields unique items. 
+    """ 
+
+    @wraps(func) 
+    def wrapper(*args, **kwargs): 
+        return unique_everseen(func(*args, **kwargs)) 
+
+    return wrapper 
+ 
 
 REL = re.compile(r"""<([^>]*\srel\s*=\s*['"]?([^'">]+)[^>]*)>""", re.I)
-# this line is here to fix emacs' cruddy broken syntax highlighting
-
-
-@unique_values
-def find_external_links(url, page):
-    """Find rel="homepage" and rel="download" links in `page`, yielding URLs"""
-
-    for match in REL.finditer(page):
-        tag, rel = match.groups()
-        rels = set(map(str.strip, rel.lower().split(',')))
-        if 'homepage' in rels or 'download' in rels:
-            for match in HREF.finditer(tag):
-                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
-
-    for tag in ("<th>Home Page", "<th>Download URL"):
-        pos = page.find(tag)
+# this line is here to fix emacs' cruddy broken syntax highlighting 
+ 
+
+@unique_values 
+def find_external_links(url, page): 
+    """Find rel="homepage" and rel="download" links in `page`, yielding URLs""" 
+ 
+    for match in REL.finditer(page): 
+        tag, rel = match.groups() 
+        rels = set(map(str.strip, rel.lower().split(','))) 
+        if 'homepage' in rels or 'download' in rels: 
+            for match in HREF.finditer(tag): 
+                yield urllib.parse.urljoin(url, htmldecode(match.group(1))) 
+ 
+    for tag in ("<th>Home Page", "<th>Download URL"): 
+        pos = page.find(tag) 
         if pos != -1:
             match = HREF.search(page, pos)
-            if match:
-                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
-
-
+            if match: 
+                yield urllib.parse.urljoin(url, htmldecode(match.group(1))) 
+ 
+ 
 class ContentChecker:
-    """
-    A null content checker that defines the interface for checking content
-    """
-
-    def feed(self, block):
-        """
-        Feed a block of data to the hash.
-        """
-        return
-
-    def is_valid(self):
-        """
-        Check the hash. Return False if validation fails.
-        """
-        return True
-
-    def report(self, reporter, template):
-        """
-        Call reporter with information about the checker (hash name)
-        substituted into the template.
-        """
-        return
-
-
-class HashChecker(ContentChecker):
-    pattern = re.compile(
-        r'(?P<hash_name>sha1|sha224|sha384|sha256|sha512|md5)='
-        r'(?P<expected>[a-f0-9]+)'
-    )
-
-    def __init__(self, hash_name, expected):
-        self.hash_name = hash_name
-        self.hash = hashlib.new(hash_name)
-        self.expected = expected
-
-    @classmethod
-    def from_url(cls, url):
-        "Construct a (possibly null) ContentChecker from a URL"
-        fragment = urllib.parse.urlparse(url)[-1]
-        if not fragment:
-            return ContentChecker()
-        match = cls.pattern.search(fragment)
-        if not match:
-            return ContentChecker()
-        return cls(**match.groupdict())
-
-    def feed(self, block):
-        self.hash.update(block)
-
-    def is_valid(self):
-        return self.hash.hexdigest() == self.expected
-
-    def report(self, reporter, template):
-        msg = template % self.hash_name
-        return reporter(msg)
-
-
-class PackageIndex(Environment):
-    """A distribution index that scans web pages for download URLs"""
-
-    def __init__(
+    """ 
+    A null content checker that defines the interface for checking content 
+    """ 
+
+    def feed(self, block): 
+        """ 
+        Feed a block of data to the hash. 
+        """ 
+        return 
+ 
+    def is_valid(self): 
+        """ 
+        Check the hash. Return False if validation fails. 
+        """ 
+        return True 
+ 
+    def report(self, reporter, template): 
+        """ 
+        Call reporter with information about the checker (hash name) 
+        substituted into the template. 
+        """ 
+        return 
+ 
+
+class HashChecker(ContentChecker): 
+    pattern = re.compile( 
+        r'(?P<hash_name>sha1|sha224|sha384|sha256|sha512|md5)=' 
+        r'(?P<expected>[a-f0-9]+)' 
+    ) 
+ 
+    def __init__(self, hash_name, expected): 
+        self.hash_name = hash_name 
+        self.hash = hashlib.new(hash_name) 
+        self.expected = expected 
+ 
+    @classmethod 
+    def from_url(cls, url): 
+        "Construct a (possibly null) ContentChecker from a URL" 
+        fragment = urllib.parse.urlparse(url)[-1] 
+        if not fragment: 
+            return ContentChecker() 
+        match = cls.pattern.search(fragment) 
+        if not match: 
+            return ContentChecker() 
+        return cls(**match.groupdict()) 
+ 
+    def feed(self, block): 
+        self.hash.update(block) 
+ 
+    def is_valid(self): 
+        return self.hash.hexdigest() == self.expected 
+ 
+    def report(self, reporter, template): 
+        msg = template % self.hash_name 
+        return reporter(msg) 
+ 
+ 
+class PackageIndex(Environment): 
+    """A distribution index that scans web pages for download URLs""" 
+ 
+    def __init__( 
             self, index_url="https://pypi.org/simple/", hosts=('*',),
-            ca_bundle=None, verify_ssl=True, *args, **kw
+            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 = {}
-        self.fetched_urls = {}
-        self.package_pages = {}
+        self.scanned_urls = {} 
+        self.fetched_urls = {} 
+        self.package_pages = {} 
         self.allows = re.compile('|'.join(map(translate, hosts))).match
-        self.to_scan = []
+        self.to_scan = [] 
         use_ssl = (
             verify_ssl
             and ssl_support.is_available
             and (ca_bundle or ssl_support.find_ca_bundle())
         )
         if use_ssl:
-            self.opener = ssl_support.opener_for(ca_bundle)
+            self.opener = ssl_support.opener_for(ca_bundle) 
         else:
             self.opener = urllib.request.urlopen
-
-    def process_url(self, url, retrieve=False):
-        """Evaluate a URL as a possible download, and maybe retrieve it"""
-        if url in self.scanned_urls and not retrieve:
-            return
-        self.scanned_urls[url] = True
-        if not URL_SCHEME(url):
-            self.process_filename(url)
-            return
-        else:
-            dists = list(distros_for_url(url))
-            if dists:
-                if not self.url_ok(url):
-                    return
-                self.debug("Found link: %s", url)
-
-        if dists or not retrieve or url in self.fetched_urls:
-            list(map(self.add, dists))
-            return  # don't need the actual page
-
-        if not self.url_ok(url):
-            self.fetched_urls[url] = True
-            return
-
-        self.info("Reading %s", url)
+ 
+    def process_url(self, url, retrieve=False): 
+        """Evaluate a URL as a possible download, and maybe retrieve it""" 
+        if url in self.scanned_urls and not retrieve: 
+            return 
+        self.scanned_urls[url] = True 
+        if not URL_SCHEME(url): 
+            self.process_filename(url) 
+            return 
+        else: 
+            dists = list(distros_for_url(url)) 
+            if dists: 
+                if not self.url_ok(url): 
+                    return 
+                self.debug("Found link: %s", url) 
+ 
+        if dists or not retrieve or url in self.fetched_urls: 
+            list(map(self.add, dists)) 
+            return  # don't need the actual page 
+ 
+        if not self.url_ok(url): 
+            self.fetched_urls[url] = True 
+            return 
+ 
+        self.info("Reading %s", url) 
         self.fetched_urls[url] = True  # prevent multiple fetch attempts
         tmpl = "Download error on %s: %%s -- Some packages may not be found!"
         f = self.open_url(url, tmpl % url)
         if f is None:
             return
-        self.fetched_urls[f.url] = True
-        if 'html' not in f.headers.get('content-type', '').lower():
+        self.fetched_urls[f.url] = True 
+        if 'html' not in f.headers.get('content-type', '').lower(): 
             f.close()  # not html, we can't process it
-            return
-
+            return 
+ 
         base = f.url  # handle redirects
-        page = f.read()
+        page = f.read() 
         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'
-            else:
-                charset = f.headers.get_param('charset') or 'latin-1'
-            page = page.decode(charset, "ignore")
-        f.close()
-        for match in HREF.finditer(page):
-            link = urllib.parse.urljoin(base, htmldecode(match.group(1)))
-            self.process_url(link)
+            if isinstance(f, urllib.error.HTTPError): 
+                # Errors have no charset, assume latin1: 
+                charset = 'latin-1' 
+            else: 
+                charset = f.headers.get_param('charset') or 'latin-1' 
+            page = page.decode(charset, "ignore") 
+        f.close() 
+        for match in HREF.finditer(page): 
+            link = urllib.parse.urljoin(base, htmldecode(match.group(1))) 
+            self.process_url(link) 
         if url.startswith(self.index_url) and getattr(f, 'code', None) != 404:
-            page = self.process_index(url, page)
-
-    def process_filename(self, fn, nested=False):
-        # process filenames or directories
-        if not os.path.exists(fn):
-            self.warn("Not found: %s", fn)
-            return
-
-        if os.path.isdir(fn) and not nested:
-            path = os.path.realpath(fn)
-            for item in os.listdir(path):
+            page = self.process_index(url, page) 
+ 
+    def process_filename(self, fn, nested=False): 
+        # process filenames or directories 
+        if not os.path.exists(fn): 
+            self.warn("Not found: %s", fn) 
+            return 
+ 
+        if os.path.isdir(fn) and not nested: 
+            path = os.path.realpath(fn) 
+            for item in os.listdir(path): 
                 self.process_filename(os.path.join(path, item), True)
-
-        dists = distros_for_filename(fn)
-        if dists:
-            self.debug("Found: %s", fn)
-            list(map(self.add, dists))
-
-    def url_ok(self, url, fatal=False):
-        s = URL_SCHEME(url)
+ 
+        dists = distros_for_filename(fn) 
+        if dists: 
+            self.debug("Found: %s", fn) 
+            list(map(self.add, dists)) 
+ 
+    def url_ok(self, url, fatal=False): 
+        s = URL_SCHEME(url) 
         is_file = s and s.group(1).lower() == 'file'
         if is_file or self.allows(urllib.parse.urlparse(url)[1]):
-            return True
+            return True 
         msg = (
             "\nNote: Bypassing %s (disallowed host; see "
             "http://bit.ly/2hrImnY for details).\n")
-        if fatal:
-            raise DistutilsError(msg % url)
-        else:
-            self.warn(msg, url)
-
-    def scan_egg_links(self, search_path):
-        dirs = filter(os.path.isdir, search_path)
-        egg_links = (
-            (path, entry)
-            for path in dirs
-            for entry in os.listdir(path)
-            if entry.endswith('.egg-link')
-        )
-        list(itertools.starmap(self.scan_egg_link, egg_links))
-
-    def scan_egg_link(self, path, entry):
-        with open(os.path.join(path, entry)) as raw_lines:
-            # filter non-empty lines
-            lines = list(filter(None, map(str.strip, raw_lines)))
-
-        if len(lines) != 2:
-            # format is not recognized; punt
-            return
-
-        egg_path, setup_path = lines
-
-        for dist in find_distributions(os.path.join(path, egg_path)):
-            dist.location = os.path.join(path, *lines)
-            dist.precedence = SOURCE_DIST
-            self.add(dist)
-
+        if fatal: 
+            raise DistutilsError(msg % url) 
+        else: 
+            self.warn(msg, url) 
+ 
+    def scan_egg_links(self, search_path): 
+        dirs = filter(os.path.isdir, search_path) 
+        egg_links = ( 
+            (path, entry) 
+            for path in dirs 
+            for entry in os.listdir(path) 
+            if entry.endswith('.egg-link') 
+        ) 
+        list(itertools.starmap(self.scan_egg_link, egg_links)) 
+ 
+    def scan_egg_link(self, path, entry): 
+        with open(os.path.join(path, entry)) as raw_lines: 
+            # filter non-empty lines 
+            lines = list(filter(None, map(str.strip, raw_lines))) 
+ 
+        if len(lines) != 2: 
+            # format is not recognized; punt 
+            return 
+ 
+        egg_path, setup_path = lines 
+ 
+        for dist in find_distributions(os.path.join(path, egg_path)): 
+            dist.location = os.path.join(path, *lines) 
+            dist.precedence = SOURCE_DIST 
+            self.add(dist) 
+ 
     def process_index(self, url, page):
-        """Process the contents of a PyPI page"""
-
-        def scan(link):
-            # Process a URL to see if it's for a package page
-            if link.startswith(self.index_url):
-                parts = list(map(
-                    urllib.parse.unquote, link[len(self.index_url):].split('/')
-                ))
+        """Process the contents of a PyPI page""" 
+
+        def scan(link): 
+            # Process a URL to see if it's for a package page 
+            if link.startswith(self.index_url): 
+                parts = list(map( 
+                    urllib.parse.unquote, link[len(self.index_url):].split('/') 
+                )) 
                 if len(parts) == 2 and '#' not in parts[1]:
-                    # it's a package page, sanitize and index it
-                    pkg = safe_name(parts[0])
-                    ver = safe_version(parts[1])
+                    # it's a package page, sanitize and index it 
+                    pkg = safe_name(parts[0]) 
+                    ver = safe_version(parts[1]) 
                     self.package_pages.setdefault(pkg.lower(), {})[link] = True
-                    return to_filename(pkg), to_filename(ver)
-            return None, None
-
-        # process an index page into the package-page index
-        for match in HREF.finditer(page):
-            try:
-                scan(urllib.parse.urljoin(url, htmldecode(match.group(1))))
-            except ValueError:
-                pass
-
+                    return to_filename(pkg), to_filename(ver) 
+            return None, None 
+ 
+        # process an index page into the package-page index 
+        for match in HREF.finditer(page): 
+            try: 
+                scan(urllib.parse.urljoin(url, htmldecode(match.group(1)))) 
+            except ValueError: 
+                pass 
+ 
         pkg, ver = scan(url)  # ensure this page is in the page index
-        if pkg:
-            # process individual package page
-            for new_url in find_external_links(url, page):
-                # Process the found URL
-                base, frag = egg_info_for_url(new_url)
-                if base.endswith('.py') and not frag:
-                    if ver:
+        if pkg: 
+            # process individual package page 
+            for new_url in find_external_links(url, page): 
+                # Process the found URL 
+                base, frag = egg_info_for_url(new_url) 
+                if base.endswith('.py') and not frag: 
+                    if ver: 
                         new_url += '#egg=%s-%s' % (pkg, ver)
-                    else:
-                        self.need_version_info(url)
-                self.scan_url(new_url)
-
-            return PYPI_MD5.sub(
+                    else: 
+                        self.need_version_info(url) 
+                self.scan_url(new_url) 
+ 
+            return PYPI_MD5.sub( 
                 lambda m: '<a href="%s#md5=%s">%s</a>' % m.group(1, 3, 2), page
-            )
-        else:
+            ) 
+        else: 
             return ""  # no sense double-scanning non-package pages
-
-    def need_version_info(self, url):
-        self.scan_all(
-            "Page at %s links to .py file(s) without version info; an index "
-            "scan is required.", url
-        )
-
-    def scan_all(self, msg=None, *args):
-        if self.index_url not in self.fetched_urls:
+ 
+    def need_version_info(self, url): 
+        self.scan_all( 
+            "Page at %s links to .py file(s) without version info; an index " 
+            "scan is required.", url 
+        ) 
+ 
+    def scan_all(self, msg=None, *args): 
+        if self.index_url not in self.fetched_urls: 
             if msg:
                 self.warn(msg, *args)
-            self.info(
-                "Scanning index of all packages (this may take a while)"
-            )
-        self.scan_url(self.index_url)
-
-    def find_packages(self, requirement):
+            self.info( 
+                "Scanning index of all packages (this may take a while)" 
+            ) 
+        self.scan_url(self.index_url) 
+ 
+    def find_packages(self, requirement): 
         self.scan_url(self.index_url + requirement.unsafe_name + '/')
-
-        if not self.package_pages.get(requirement.key):
-            # Fall back to safe version of the name
+ 
+        if not self.package_pages.get(requirement.key): 
+            # Fall back to safe version of the name 
             self.scan_url(self.index_url + requirement.project_name + '/')
-
-        if not self.package_pages.get(requirement.key):
-            # We couldn't find the target package, so search the index page too
-            self.not_found_in_index(requirement)
-
+ 
+        if not self.package_pages.get(requirement.key): 
+            # We couldn't find the target package, so search the index page too 
+            self.not_found_in_index(requirement) 
+ 
         for url in list(self.package_pages.get(requirement.key, ())):
-            # scan each page that might be related to the desired package
-            self.scan_url(url)
-
-    def obtain(self, requirement, installer=None):
-        self.prescan()
-        self.find_packages(requirement)
-        for dist in self[requirement.key]:
-            if dist in requirement:
-                return dist
-            self.debug("%s does not match %s", requirement, dist)
+            # scan each page that might be related to the desired package 
+            self.scan_url(url) 
+ 
+    def obtain(self, requirement, installer=None): 
+        self.prescan() 
+        self.find_packages(requirement) 
+        for dist in self[requirement.key]: 
+            if dist in requirement: 
+                return dist 
+            self.debug("%s does not match %s", requirement, dist) 
         return super(PackageIndex, self).obtain(requirement, installer)
-
-    def check_hash(self, checker, filename, tfp):
-        """
-        checker is a ContentChecker
-        """
+ 
+    def check_hash(self, checker, filename, tfp): 
+        """ 
+        checker is a ContentChecker 
+        """ 
         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; "
+            "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))
-            )
-
-    def add_find_links(self, urls):
-        """Add `urls` to the list that will be prescanned for searches"""
-        for url in urls:
-            if (
+            ) 
+ 
+    def add_find_links(self, urls): 
+        """Add `urls` to the list that will be prescanned for searches""" 
+        for url in urls: 
+            if ( 
                 self.to_scan is None  # if we have already "gone online"
                 or not URL_SCHEME(url)  # or it's a local file/directory
-                or url.startswith('file:')
+                or url.startswith('file:') 
                 or list(distros_for_url(url))  # or a direct package link
-            ):
-                # then go ahead and process it now
-                self.scan_url(url)
-            else:
-                # otherwise, defer retrieval till later
-                self.to_scan.append(url)
-
-    def prescan(self):
-        """Scan urls scheduled for prescanning (e.g. --find-links)"""
-        if self.to_scan:
-            list(map(self.scan_url, self.to_scan))
+            ): 
+                # then go ahead and process it now 
+                self.scan_url(url) 
+            else: 
+                # otherwise, defer retrieval till later 
+                self.to_scan.append(url) 
+ 
+    def prescan(self): 
+        """Scan urls scheduled for prescanning (e.g. --find-links)""" 
+        if self.to_scan: 
+            list(map(self.scan_url, self.to_scan)) 
         self.to_scan = None  # from now on, go ahead and process immediately
-
-    def not_found_in_index(self, requirement):
+ 
+    def not_found_in_index(self, requirement): 
         if self[requirement.key]:  # we've seen at least one distro
-            meth, msg = self.info, "Couldn't retrieve index page for %r"
+            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,
-                "Couldn't find index page for %r (maybe misspelled?)")
-        meth(msg, requirement.unsafe_name)
-        self.scan_all()
-
-    def download(self, spec, tmpdir):
-        """Locate and/or download `spec` to `tmpdir`, returning a local path
-
-        `spec` may be a ``Requirement`` object, or a string containing a URL,
-        an existing local filename, or a project/version requirement spec
-        (i.e. the string form of a ``Requirement`` object).  If it is the URL
-        of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
-        that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
-        automatically created alongside the downloaded file.
-
-        If `spec` is a ``Requirement`` object or a string containing a
-        project/version requirement spec, this method returns the location of
-        a matching distribution (possibly after downloading it to `tmpdir`).
-        If `spec` is a locally existing file or directory name, it is simply
-        returned unchanged.  If `spec` is a URL, it is downloaded to a subpath
-        of `tmpdir`, and the local filename is returned.  Various errors may be
-        raised if a problem occurs during downloading.
-        """
+                "Couldn't find index page for %r (maybe misspelled?)") 
+        meth(msg, requirement.unsafe_name) 
+        self.scan_all() 
+ 
+    def download(self, spec, tmpdir): 
+        """Locate and/or download `spec` to `tmpdir`, returning a local path 
+ 
+        `spec` may be a ``Requirement`` object, or a string containing a URL, 
+        an existing local filename, or a project/version requirement spec 
+        (i.e. the string form of a ``Requirement`` object).  If it is the URL 
+        of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one 
+        that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is 
+        automatically created alongside the downloaded file. 
+ 
+        If `spec` is a ``Requirement`` object or a string containing a 
+        project/version requirement spec, this method returns the location of 
+        a matching distribution (possibly after downloading it to `tmpdir`). 
+        If `spec` is a locally existing file or directory name, it is simply 
+        returned unchanged.  If `spec` is a URL, it is downloaded to a subpath 
+        of `tmpdir`, and the local filename is returned.  Various errors may be 
+        raised if a problem occurs during downloading. 
+        """ 
         if not isinstance(spec, Requirement):
-            scheme = URL_SCHEME(spec)
-            if scheme:
-                # It's a url, download it to tmpdir
-                found = self._download_url(scheme.group(1), spec, tmpdir)
-                base, fragment = egg_info_for_url(spec)
-                if base.endswith('.py'):
+            scheme = URL_SCHEME(spec) 
+            if scheme: 
+                # It's a url, download it to tmpdir 
+                found = self._download_url(scheme.group(1), spec, tmpdir) 
+                base, fragment = egg_info_for_url(spec) 
+                if base.endswith('.py'): 
                     found = self.gen_setup(found, fragment, tmpdir)
-                return found
-            elif os.path.exists(spec):
-                # Existing file or directory, just return it
-                return spec
-            else:
+                return found 
+            elif os.path.exists(spec): 
+                # Existing file or directory, just return it 
+                return spec 
+            else: 
                 spec = parse_requirement_arg(spec)
         return getattr(self.fetch_distribution(spec, tmpdir), 'location', None)
-
-    def fetch_distribution(
-            self, requirement, tmpdir, force_scan=False, source=False,
+ 
+    def fetch_distribution( 
+            self, requirement, tmpdir, force_scan=False, source=False, 
             develop_ok=False, local_index=None):
-        """Obtain a distribution suitable for fulfilling `requirement`
-
-        `requirement` must be a ``pkg_resources.Requirement`` instance.
-        If necessary, or if the `force_scan` flag is set, the requirement is
-        searched for in the (online) package index as well as the locally
-        installed packages.  If a distribution matching `requirement` is found,
-        the returned distribution's ``location`` is the value you would have
-        gotten from calling the ``download()`` method with the matching
-        distribution's URL or filename.  If no matching distribution is found,
-        ``None`` is returned.
-
-        If the `source` flag is set, only source distributions and source
-        checkout links will be considered.  Unless the `develop_ok` flag is
-        set, development and system eggs (i.e., those using the ``.egg-info``
-        format) will be ignored.
-        """
-        # process a Requirement
-        self.info("Searching for %s", requirement)
-        skipped = {}
-        dist = None
-
-        def find(req, env=None):
-            if env is None:
-                env = self
-            # Find a matching distribution; may be called more than once
-
-            for dist in env[req.key]:
-
+        """Obtain a distribution suitable for fulfilling `requirement` 
+ 
+        `requirement` must be a ``pkg_resources.Requirement`` instance. 
+        If necessary, or if the `force_scan` flag is set, the requirement is 
+        searched for in the (online) package index as well as the locally 
+        installed packages.  If a distribution matching `requirement` is found, 
+        the returned distribution's ``location`` is the value you would have 
+        gotten from calling the ``download()`` method with the matching 
+        distribution's URL or filename.  If no matching distribution is found, 
+        ``None`` is returned. 
+ 
+        If the `source` flag is set, only source distributions and source 
+        checkout links will be considered.  Unless the `develop_ok` flag is 
+        set, development and system eggs (i.e., those using the ``.egg-info`` 
+        format) will be ignored. 
+        """ 
+        # process a Requirement 
+        self.info("Searching for %s", requirement) 
+        skipped = {} 
+        dist = None 
+ 
+        def find(req, env=None): 
+            if env is None: 
+                env = self 
+            # Find a matching distribution; may be called more than once 
+ 
+            for dist in env[req.key]: 
+ 
                 if dist.precedence == DEVELOP_DIST and not develop_ok:
-                    if dist not in skipped:
+                    if dist not in skipped: 
                         self.warn(
                             "Skipping development or system egg: %s", dist,
                         )
-                        skipped[dist] = 1
-                    continue
-
+                        skipped[dist] = 1 
+                    continue 
+ 
                 test = (
                     dist in req
                     and (dist.precedence <= SOURCE_DIST or not source)
@@ -636,311 +636,311 @@ class PackageIndex(Environment):
                     dist.download_location = loc
                     if os.path.exists(dist.download_location):
                         return dist
-
-        if force_scan:
-            self.prescan()
-            self.find_packages(requirement)
-            dist = find(requirement)
-
+ 
+        if force_scan: 
+            self.prescan() 
+            self.find_packages(requirement) 
+            dist = find(requirement) 
+ 
         if not dist and local_index is not None:
             dist = find(requirement, local_index)
-
-        if dist is None:
-            if self.to_scan is not None:
-                self.prescan()
-            dist = find(requirement)
-
-        if dist is None and not force_scan:
-            self.find_packages(requirement)
-            dist = find(requirement)
-
-        if dist is None:
-            self.warn(
+ 
+        if dist is None: 
+            if self.to_scan is not None: 
+                self.prescan() 
+            dist = find(requirement) 
+ 
+        if dist is None and not force_scan: 
+            self.find_packages(requirement) 
+            dist = find(requirement) 
+ 
+        if dist is None: 
+            self.warn( 
                 "No local packages or working download links found for %s%s",
-                (source and "a source distribution of " or ""),
-                requirement,
-            )
-        else:
-            self.info("Best match: %s", dist)
+                (source and "a source distribution of " or ""), 
+                requirement, 
+            ) 
+        else: 
+            self.info("Best match: %s", dist) 
             return dist.clone(location=dist.download_location)
-
-    def fetch(self, requirement, tmpdir, force_scan=False, source=False):
-        """Obtain a file suitable for fulfilling `requirement`
-
-        DEPRECATED; use the ``fetch_distribution()`` method now instead.  For
-        backward compatibility, this routine is identical but returns the
-        ``location`` of the downloaded distribution instead of a distribution
-        object.
-        """
+ 
+    def fetch(self, requirement, tmpdir, force_scan=False, source=False): 
+        """Obtain a file suitable for fulfilling `requirement` 
+ 
+        DEPRECATED; use the ``fetch_distribution()`` method now instead.  For 
+        backward compatibility, this routine is identical but returns the 
+        ``location`` of the downloaded distribution instead of a distribution 
+        object. 
+        """ 
         dist = self.fetch_distribution(requirement, tmpdir, force_scan, source)
-        if dist is not None:
-            return dist.location
-        return None
-
-    def gen_setup(self, filename, fragment, tmpdir):
-        match = EGG_FRAGMENT.match(fragment)
-        dists = match and [
-            d for d in
-            interpret_distro_name(filename, match.group(1), None) if d.version
-        ] or []
-
+        if dist is not None: 
+            return dist.location 
+        return None 
+ 
+    def gen_setup(self, filename, fragment, tmpdir): 
+        match = EGG_FRAGMENT.match(fragment) 
+        dists = match and [ 
+            d for d in 
+            interpret_distro_name(filename, match.group(1), None) if d.version 
+        ] or [] 
+ 
         if len(dists) == 1:  # unambiguous ``#egg`` fragment
-            basename = os.path.basename(filename)
-
-            # Make sure the file has been downloaded to the temp dir.
-            if os.path.dirname(filename) != tmpdir:
-                dst = os.path.join(tmpdir, basename)
-                from setuptools.command.easy_install import samefile
-                if not samefile(filename, dst):
-                    shutil.copy2(filename, dst)
+            basename = os.path.basename(filename) 
+ 
+            # Make sure the file has been downloaded to the temp dir. 
+            if os.path.dirname(filename) != tmpdir: 
+                dst = os.path.join(tmpdir, basename) 
+                from setuptools.command.easy_install import samefile 
+                if not samefile(filename, dst): 
+                    shutil.copy2(filename, dst) 
                     filename = dst
-
-            with open(os.path.join(tmpdir, 'setup.py'), 'w') as file:
-                file.write(
-                    "from setuptools import setup\n"
-                    "setup(name=%r, version=%r, py_modules=[%r])\n"
-                    % (
-                        dists[0].project_name, dists[0].version,
-                        os.path.splitext(basename)[0]
-                    )
-                )
-            return filename
-
-        elif match:
-            raise DistutilsError(
-                "Can't unambiguously interpret project/version identifier %r; "
-                "any dashes in the name or version should be escaped using "
+ 
+            with open(os.path.join(tmpdir, 'setup.py'), 'w') as file: 
+                file.write( 
+                    "from setuptools import setup\n" 
+                    "setup(name=%r, version=%r, py_modules=[%r])\n" 
+                    % ( 
+                        dists[0].project_name, dists[0].version, 
+                        os.path.splitext(basename)[0] 
+                    ) 
+                ) 
+            return filename 
+ 
+        elif match: 
+            raise DistutilsError( 
+                "Can't unambiguously interpret project/version identifier %r; " 
+                "any dashes in the name or version should be escaped using " 
                 "underscores. %r" % (fragment, dists)
-            )
-        else:
-            raise DistutilsError(
-                "Can't process plain .py files without an '#egg=name-version'"
-                " suffix to enable automatic setup script generation."
-            )
-
-    dl_blocksize = 8192
-
-    def _download_to(self, url, filename):
-        self.info("Downloading %s", url)
-        # Download the file
+            ) 
+        else: 
+            raise DistutilsError( 
+                "Can't process plain .py files without an '#egg=name-version'" 
+                " suffix to enable automatic setup script generation." 
+            ) 
+ 
+    dl_blocksize = 8192 
+
+    def _download_to(self, url, filename): 
+        self.info("Downloading %s", url) 
+        # Download the file 
         fp = None
-        try:
-            checker = HashChecker.from_url(url)
+        try: 
+            checker = HashChecker.from_url(url) 
             fp = self.open_url(url)
-            if isinstance(fp, urllib.error.HTTPError):
-                raise DistutilsError(
+            if isinstance(fp, urllib.error.HTTPError): 
+                raise DistutilsError( 
                     "Can't download %s: %s %s" % (url, fp.code, fp.msg)
-                )
-            headers = fp.info()
-            blocknum = 0
-            bs = self.dl_blocksize
-            size = -1
-            if "content-length" in headers:
-                # Some servers return multiple Content-Length headers :(
-                sizes = get_all_headers(headers, 'Content-Length')
-                size = max(map(int, sizes))
-                self.reporthook(url, filename, blocknum, bs, size)
+                ) 
+            headers = fp.info() 
+            blocknum = 0 
+            bs = self.dl_blocksize 
+            size = -1 
+            if "content-length" in headers: 
+                # Some servers return multiple Content-Length headers :( 
+                sizes = get_all_headers(headers, 'Content-Length') 
+                size = max(map(int, sizes)) 
+                self.reporthook(url, filename, blocknum, bs, size) 
             with open(filename, 'wb') as tfp:
-                while True:
-                    block = fp.read(bs)
-                    if block:
-                        checker.feed(block)
-                        tfp.write(block)
-                        blocknum += 1
-                        self.reporthook(url, filename, blocknum, bs, size)
-                    else:
-                        break
-                self.check_hash(checker, filename, tfp)
-            return headers
-        finally:
+                while True: 
+                    block = fp.read(bs) 
+                    if block: 
+                        checker.feed(block) 
+                        tfp.write(block) 
+                        blocknum += 1 
+                        self.reporthook(url, filename, blocknum, bs, size) 
+                    else: 
+                        break 
+                self.check_hash(checker, filename, tfp) 
+            return headers 
+        finally: 
             if fp:
                 fp.close()
-
-    def reporthook(self, url, filename, blocknum, blksize, size):
+ 
+    def reporthook(self, url, filename, blocknum, blksize, size): 
         pass  # no-op
-
-    def open_url(self, url, warning=None):
-        if url.startswith('file:'):
-            return local_open(url)
-        try:
-            return open_with_auth(url, self.opener)
-        except (ValueError, http_client.InvalidURL) as v:
-            msg = ' '.join([str(arg) for arg in v.args])
-            if warning:
-                self.warn(warning, msg)
-            else:
-                raise DistutilsError('%s %s' % (url, msg))
-        except urllib.error.HTTPError as v:
-            return v
-        except urllib.error.URLError as v:
-            if warning:
-                self.warn(warning, v.reason)
-            else:
-                raise DistutilsError("Download error for %s: %s"
-                                     % (url, v.reason))
-        except http_client.BadStatusLine as v:
-            if warning:
-                self.warn(warning, v.line)
-            else:
-                raise DistutilsError(
-                    '%s returned a bad status line. The server might be '
-                    'down, %s' %
-                    (url, v.line)
-                )
+ 
+    def open_url(self, url, warning=None): 
+        if url.startswith('file:'): 
+            return local_open(url) 
+        try: 
+            return open_with_auth(url, self.opener) 
+        except (ValueError, http_client.InvalidURL) as v: 
+            msg = ' '.join([str(arg) for arg in v.args]) 
+            if warning: 
+                self.warn(warning, msg) 
+            else: 
+                raise DistutilsError('%s %s' % (url, msg)) 
+        except urllib.error.HTTPError as v: 
+            return v 
+        except urllib.error.URLError as v: 
+            if warning: 
+                self.warn(warning, v.reason) 
+            else: 
+                raise DistutilsError("Download error for %s: %s" 
+                                     % (url, v.reason)) 
+        except http_client.BadStatusLine as v: 
+            if warning: 
+                self.warn(warning, v.line) 
+            else: 
+                raise DistutilsError( 
+                    '%s returned a bad status line. The server might be ' 
+                    'down, %s' % 
+                    (url, v.line) 
+                ) 
         except (http_client.HTTPException, socket.error) as v:
-            if warning:
-                self.warn(warning, v)
-            else:
-                raise DistutilsError("Download error for %s: %s"
-                                     % (url, v))
-
-    def _download_url(self, scheme, url, tmpdir):
-        # Determine download filename
-        #
-        name, fragment = egg_info_for_url(url)
-        if name:
-            while '..' in name:
+            if warning: 
+                self.warn(warning, v) 
+            else: 
+                raise DistutilsError("Download error for %s: %s" 
+                                     % (url, v)) 
+ 
+    def _download_url(self, scheme, url, tmpdir): 
+        # Determine download filename 
+        # 
+        name, fragment = egg_info_for_url(url) 
+        if name: 
+            while '..' in name: 
                 name = name.replace('..', '.').replace('\\', '_')
-        else:
+        else: 
             name = "__downloaded__"  # default if URL has no path contents
-
-        if name.endswith('.egg.zip'):
+ 
+        if name.endswith('.egg.zip'): 
             name = name[:-4]  # strip the extra .zip before download
-
+ 
         filename = os.path.join(tmpdir, name)
-
-        # Download the file
-        #
+ 
+        # Download the file 
+        # 
         if scheme == 'svn' or scheme.startswith('svn+'):
-            return self._download_svn(url, filename)
+            return self._download_svn(url, filename) 
         elif scheme == 'git' or scheme.startswith('git+'):
-            return self._download_git(url, filename)
-        elif scheme.startswith('hg+'):
-            return self._download_hg(url, filename)
+            return self._download_git(url, filename) 
+        elif scheme.startswith('hg+'): 
+            return self._download_hg(url, filename) 
         elif scheme == 'file':
-            return urllib.request.url2pathname(urllib.parse.urlparse(url)[2])
-        else:
+            return urllib.request.url2pathname(urllib.parse.urlparse(url)[2]) 
+        else: 
             self.url_ok(url, True)  # raises error if not allowed
-            return self._attempt_download(url, filename)
-
-    def scan_url(self, url):
-        self.process_url(url, True)
-
-    def _attempt_download(self, url, filename):
-        headers = self._download_to(url, filename)
+            return self._attempt_download(url, filename) 
+ 
+    def scan_url(self, url): 
+        self.process_url(url, True) 
+ 
+    def _attempt_download(self, url, filename): 
+        headers = self._download_to(url, filename) 
         if 'html' in headers.get('content-type', '').lower():
-            return self._download_html(url, headers, filename)
-        else:
-            return filename
-
-    def _download_html(self, url, headers, filename):
-        file = open(filename)
-        for line in file:
-            if line.strip():
-                # Check for a subversion index page
-                if re.search(r'<title>([^- ]+ - )?Revision \d+:', line):
-                    # it's a subversion index page:
-                    file.close()
-                    os.unlink(filename)
-                    return self._download_svn(url, filename)
+            return self._download_html(url, headers, filename) 
+        else: 
+            return filename 
+ 
+    def _download_html(self, url, headers, filename): 
+        file = open(filename) 
+        for line in file: 
+            if line.strip(): 
+                # Check for a subversion index page 
+                if re.search(r'<title>([^- ]+ - )?Revision \d+:', line): 
+                    # it's a subversion index page: 
+                    file.close() 
+                    os.unlink(filename) 
+                    return self._download_svn(url, filename) 
                 break  # not an index page
-        file.close()
-        os.unlink(filename)
+        file.close() 
+        os.unlink(filename) 
         raise DistutilsError("Unexpected HTML page found at " + url)
-
-    def _download_svn(self, url, filename):
+ 
+    def _download_svn(self, url, filename): 
         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:]:
+        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)
-                if auth:
-                    if ':' in auth:
+                if auth: 
+                    if ':' in auth: 
                         user, pw = auth.split(':', 1)
-                        creds = " --username=%s --password=%s" % (user, pw)
-                    else:
+                        creds = " --username=%s --password=%s" % (user, pw) 
+                    else: 
                         creds = " --username=" + auth
-                    netloc = host
-                    parts = scheme, netloc, url, p, q, f
-                    url = urllib.parse.urlunparse(parts)
-        self.info("Doing subversion checkout from %s to %s", url, filename)
-        os.system("svn checkout%s -q %s %s" % (creds, url, filename))
-        return filename
-
-    @staticmethod
-    def _vcs_split_rev_from_url(url, pop_prefix=False):
-        scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)
-
-        scheme = scheme.split('+', 1)[-1]
-
-        # Some fragment identification fails
+                    netloc = host 
+                    parts = scheme, netloc, url, p, q, f 
+                    url = urllib.parse.urlunparse(parts) 
+        self.info("Doing subversion checkout from %s to %s", url, filename) 
+        os.system("svn checkout%s -q %s %s" % (creds, url, filename)) 
+        return filename 
+ 
+    @staticmethod 
+    def _vcs_split_rev_from_url(url, pop_prefix=False): 
+        scheme, netloc, path, query, frag = urllib.parse.urlsplit(url) 
+ 
+        scheme = scheme.split('+', 1)[-1] 
+ 
+        # Some fragment identification fails 
         path = path.split('#', 1)[0]
-
-        rev = None
-        if '@' in path:
-            path, rev = path.rsplit('@', 1)
-
-        # Also, discard fragment
-        url = urllib.parse.urlunsplit((scheme, netloc, path, query, ''))
-
-        return url, rev
-
-    def _download_git(self, url, filename):
+ 
+        rev = None 
+        if '@' in path: 
+            path, rev = path.rsplit('@', 1) 
+ 
+        # Also, discard fragment 
+        url = urllib.parse.urlunsplit((scheme, netloc, path, query, '')) 
+ 
+        return url, rev 
+ 
+    def _download_git(self, url, filename): 
         filename = filename.split('#', 1)[0]
-        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
-
-        self.info("Doing git clone from %s to %s", url, filename)
-        os.system("git clone --quiet %s %s" % (url, filename))
-
-        if rev is not None:
-            self.info("Checking out %s", rev)
+        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True) 
+ 
+        self.info("Doing git clone from %s to %s", url, filename) 
+        os.system("git clone --quiet %s %s" % (url, filename)) 
+ 
+        if rev is not None: 
+            self.info("Checking out %s", rev) 
             os.system("git -C %s checkout --quiet %s" % (
-                filename,
-                rev,
-            ))
-
-        return filename
-
-    def _download_hg(self, url, filename):
+                filename, 
+                rev, 
+            )) 
+ 
+        return filename 
+ 
+    def _download_hg(self, url, filename): 
         filename = filename.split('#', 1)[0]
-        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
-
-        self.info("Doing hg clone from %s to %s", url, filename)
-        os.system("hg clone --quiet %s %s" % (url, filename))
-
-        if rev is not None:
-            self.info("Updating to %s", rev)
+        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True) 
+ 
+        self.info("Doing hg clone from %s to %s", url, filename) 
+        os.system("hg clone --quiet %s %s" % (url, filename)) 
+ 
+        if rev is not None: 
+            self.info("Updating to %s", rev) 
             os.system("hg --cwd %s up -C -r %s -q" % (
-                filename,
-                rev,
-            ))
-
-        return filename
-
-    def debug(self, msg, *args):
-        log.debug(msg, *args)
-
-    def info(self, msg, *args):
-        log.info(msg, *args)
-
-    def warn(self, msg, *args):
-        log.warn(msg, *args)
-
-
-# This pattern matches a character entity reference (a decimal numeric
-# references, a hexadecimal numeric reference, or a named reference).
-entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub
-
-
-def decode_entity(match):
+                filename, 
+                rev, 
+            )) 
+ 
+        return filename 
+ 
+    def debug(self, msg, *args): 
+        log.debug(msg, *args) 
+ 
+    def info(self, msg, *args): 
+        log.info(msg, *args) 
+ 
+    def warn(self, msg, *args): 
+        log.warn(msg, *args) 
+ 
+
+# This pattern matches a character entity reference (a decimal numeric 
+# references, a hexadecimal numeric reference, or a named reference). 
+entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub 
+ 
+
+def decode_entity(match): 
     what = match.group(0)
     return unescape(what)
+ 
 
-
-def htmldecode(text):
+def htmldecode(text): 
     """
     Decode HTML entities in the given text.
 
@@ -949,146 +949,146 @@ def htmldecode(text):
     ...     '?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)
-
-
-def socket_timeout(timeout=15):
-    def _socket_timeout(func):
-        def _socket_timeout(*args, **kwargs):
-            old_timeout = socket.getdefaulttimeout()
-            socket.setdefaulttimeout(timeout)
-            try:
-                return func(*args, **kwargs)
-            finally:
-                socket.setdefaulttimeout(old_timeout)
-
-        return _socket_timeout
-
-    return _socket_timeout
-
-
-def _encode_auth(auth):
-    """
-    A function compatible with Python 2.3-3.3 that will encode
-    auth from a URL suitable for an HTTP header.
-    >>> str(_encode_auth('username%3Apassword'))
-    'dXNlcm5hbWU6cGFzc3dvcmQ='
-
-    Long auth strings should not cause a newline to be inserted.
-    >>> long_auth = 'username:' + 'password'*10
-    >>> chr(10) in str(_encode_auth(long_auth))
-    False
-    """
-    auth_s = urllib.parse.unquote(auth)
-    # convert to bytes
-    auth_bytes = auth_s.encode()
+    return entity_sub(decode_entity, text) 
+ 
+
+def socket_timeout(timeout=15): 
+    def _socket_timeout(func): 
+        def _socket_timeout(*args, **kwargs): 
+            old_timeout = socket.getdefaulttimeout() 
+            socket.setdefaulttimeout(timeout) 
+            try: 
+                return func(*args, **kwargs) 
+            finally: 
+                socket.setdefaulttimeout(old_timeout) 
+
+        return _socket_timeout 
+
+    return _socket_timeout 
+ 
+
+def _encode_auth(auth): 
+    """ 
+    A function compatible with Python 2.3-3.3 that will encode 
+    auth from a URL suitable for an HTTP header. 
+    >>> str(_encode_auth('username%3Apassword')) 
+    'dXNlcm5hbWU6cGFzc3dvcmQ=' 
+ 
+    Long auth strings should not cause a newline to be inserted. 
+    >>> long_auth = 'username:' + 'password'*10 
+    >>> chr(10) in str(_encode_auth(long_auth)) 
+    False 
+    """ 
+    auth_s = urllib.parse.unquote(auth) 
+    # convert to bytes 
+    auth_bytes = auth_s.encode() 
     encoded_bytes = base64.b64encode(auth_bytes)
-    # convert back to a string
-    encoded = encoded_bytes.decode()
-    # strip the trailing carriage return
+    # convert back to a string 
+    encoded = encoded_bytes.decode() 
+    # strip the trailing carriage return 
     return encoded.replace('\n', '')
-
+ 
 
 class Credential:
-    """
-    A username/password pair. Use like a namedtuple.
-    """
-
-    def __init__(self, username, password):
-        self.username = username
-        self.password = password
-
-    def __iter__(self):
-        yield self.username
-        yield self.password
-
-    def __str__(self):
-        return '%(username)s:%(password)s' % vars(self)
-
-
-class PyPIConfig(configparser.RawConfigParser):
-    def __init__(self):
-        """
-        Load from ~/.pypirc
-        """
-        defaults = dict.fromkeys(['username', 'password', 'repository'], '')
-        configparser.RawConfigParser.__init__(self, defaults)
-
-        rc = os.path.join(os.path.expanduser('~'), '.pypirc')
-        if os.path.exists(rc):
-            self.read(rc)
-
-    @property
-    def creds_by_repository(self):
-        sections_with_repositories = [
-            section for section in self.sections()
-            if self.get(section, 'repository').strip()
-        ]
-
-        return dict(map(self._get_repo_cred, sections_with_repositories))
-
-    def _get_repo_cred(self, section):
-        repo = self.get(section, 'repository').strip()
-        return repo, Credential(
-            self.get(section, 'username').strip(),
-            self.get(section, 'password').strip(),
-        )
-
-    def find_credential(self, url):
-        """
-        If the URL indicated appears to be a repository defined in this
-        config, return the credential for that repository.
-        """
-        for repository, cred in self.creds_by_repository.items():
-            if url.startswith(repository):
-                return cred
-
-
-def open_with_auth(url, opener=urllib.request.urlopen):
-    """Open a urllib2 request, handling HTTP authentication"""
-
+    """ 
+    A username/password pair. Use like a namedtuple. 
+    """ 
+
+    def __init__(self, username, password): 
+        self.username = username 
+        self.password = password 
+ 
+    def __iter__(self): 
+        yield self.username 
+        yield self.password 
+ 
+    def __str__(self): 
+        return '%(username)s:%(password)s' % vars(self) 
+ 
+
+class PyPIConfig(configparser.RawConfigParser): 
+    def __init__(self): 
+        """ 
+        Load from ~/.pypirc 
+        """ 
+        defaults = dict.fromkeys(['username', 'password', 'repository'], '') 
+        configparser.RawConfigParser.__init__(self, defaults) 
+ 
+        rc = os.path.join(os.path.expanduser('~'), '.pypirc') 
+        if os.path.exists(rc): 
+            self.read(rc) 
+ 
+    @property 
+    def creds_by_repository(self): 
+        sections_with_repositories = [ 
+            section for section in self.sections() 
+            if self.get(section, 'repository').strip() 
+        ] 
+ 
+        return dict(map(self._get_repo_cred, sections_with_repositories)) 
+ 
+    def _get_repo_cred(self, section): 
+        repo = self.get(section, 'repository').strip() 
+        return repo, Credential( 
+            self.get(section, 'username').strip(), 
+            self.get(section, 'password').strip(), 
+        ) 
+ 
+    def find_credential(self, url): 
+        """ 
+        If the URL indicated appears to be a repository defined in this 
+        config, return the credential for that repository. 
+        """ 
+        for repository, cred in self.creds_by_repository.items(): 
+            if url.startswith(repository): 
+                return cred 
+ 
+ 
+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
-
-    # Double scheme does not raise on Mac OS X as revealed by a
-    # failing test. We would expect "nonnumeric port". Refs #20.
-    if netloc.endswith(':'):
-        raise http_client.InvalidURL("nonnumeric port: ''")
-
-    if scheme in ('http', 'https'):
+ 
+    # Double scheme does not raise on Mac OS X as revealed by a 
+    # failing test. We would expect "nonnumeric port". Refs #20. 
+    if netloc.endswith(':'): 
+        raise http_client.InvalidURL("nonnumeric port: ''") 
+ 
+    if scheme in ('http', 'https'): 
         auth, address = _splituser(netloc)
-    else:
-        auth = None
-
-    if not auth:
-        cred = PyPIConfig().find_credential(url)
-        if cred:
-            auth = str(cred)
-            info = cred.username, url
+    else: 
+        auth = None 
+ 
+    if not auth: 
+        cred = PyPIConfig().find_credential(url) 
+        if cred: 
+            auth = str(cred) 
+            info = cred.username, url 
             log.info('Authenticating as %s for %s (from .pypirc)', *info)
-
-    if auth:
-        auth = "Basic " + _encode_auth(auth)
+ 
+    if auth: 
+        auth = "Basic " + _encode_auth(auth) 
         parts = scheme, address, path, params, query, frag
-        new_url = urllib.parse.urlunparse(parts)
-        request = urllib.request.Request(new_url)
-        request.add_header("Authorization", auth)
-    else:
-        request = urllib.request.Request(url)
-
-    request.add_header('User-Agent', user_agent)
-    fp = opener(request)
-
-    if auth:
-        # 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)
+        new_url = urllib.parse.urlunparse(parts) 
+        request = urllib.request.Request(new_url) 
+        request.add_header("Authorization", auth) 
+    else: 
+        request = urllib.request.Request(url) 
+ 
+    request.add_header('User-Agent', user_agent) 
+    fp = opener(request) 
+ 
+    if auth: 
+        # 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:
-            parts = s2, netloc, path2, param2, query2, frag2
-            fp.url = urllib.parse.urlunparse(parts)
-
-    return fp
-
+            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):
@@ -1097,40 +1097,40 @@ def _splituser(host):
     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)
-
-
-def fix_sf_url(url):
+# adding a timeout to avoid freezing package_index 
+open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth) 
+ 
+ 
+def fix_sf_url(url): 
     return url  # backward compatibility
-
-
-def local_open(url):
-    """Read a local path, with special support for directories"""
-    scheme, server, path, param, query, frag = urllib.parse.urlparse(url)
-    filename = urllib.request.url2pathname(path)
-    if os.path.isfile(filename):
-        return urllib.request.urlopen(url)
-    elif path.endswith('/') and os.path.isdir(filename):
-        files = []
-        for f in os.listdir(filename):
-            filepath = os.path.join(filename, f)
-            if f == 'index.html':
-                with open(filepath, 'r') as fp:
-                    body = fp.read()
-                break
-            elif os.path.isdir(filepath):
-                f += '/'
-            files.append('<a href="{name}">{name}</a>'.format(name=f))
-        else:
+ 
+
+def local_open(url): 
+    """Read a local path, with special support for directories""" 
+    scheme, server, path, param, query, frag = urllib.parse.urlparse(url) 
+    filename = urllib.request.url2pathname(path) 
+    if os.path.isfile(filename): 
+        return urllib.request.urlopen(url) 
+    elif path.endswith('/') and os.path.isdir(filename): 
+        files = [] 
+        for f in os.listdir(filename): 
+            filepath = os.path.join(filename, f) 
+            if f == 'index.html': 
+                with open(filepath, 'r') as fp: 
+                    body = fp.read() 
+                break 
+            elif os.path.isdir(filepath): 
+                f += '/' 
+            files.append('<a href="{name}">{name}</a>'.format(name=f)) 
+        else: 
             tmpl = (
                 "<html><head><title>{url}</title>"
-                "</head><body>{files}</body></html>")
-            body = tmpl.format(url=url, files='\n'.join(files))
-        status, message = 200, "OK"
-    else:
-        status, message, body = 404, "Path not found", "Not found"
-
-    headers = {'content-type': 'text/html'}
-    body_stream = six.StringIO(body)
-    return urllib.error.HTTPError(url, status, message, headers, body_stream)
+                "</head><body>{files}</body></html>") 
+            body = tmpl.format(url=url, files='\n'.join(files)) 
+        status, message = 200, "OK" 
+    else: 
+        status, message, body = 404, "Path not found", "Not found" 
+ 
+    headers = {'content-type': 'text/html'} 
+    body_stream = six.StringIO(body) 
+    return urllib.error.HTTPError(url, status, message, headers, body_stream) 
diff --git a/contrib/python/setuptools/py2/setuptools/py27compat.py b/contrib/python/setuptools/py2/setuptools/py27compat.py
index 1d57360f4e..3d030d052b 100644
--- a/contrib/python/setuptools/py2/setuptools/py27compat.py
+++ b/contrib/python/setuptools/py2/setuptools/py27compat.py
@@ -1,19 +1,19 @@
-"""
-Compatibility Support for Python 2.7 and earlier
-"""
-
+""" 
+Compatibility Support for Python 2.7 and earlier 
+""" 
+ 
 import sys
 import platform
-
+ 
 from setuptools.extern import six
 
 
-def get_all_headers(message, key):
+def get_all_headers(message, key): 
     """
     Given an HTTPMessage, return all headers matching a given key.
     """
     return message.get_all(key)
-
+ 
 
 if six.PY2:
     def get_all_headers(message, key):
diff --git a/contrib/python/setuptools/py2/setuptools/py31compat.py b/contrib/python/setuptools/py2/setuptools/py31compat.py
index e1da7ee2a2..a01180deda 100644
--- a/contrib/python/setuptools/py2/setuptools/py31compat.py
+++ b/contrib/python/setuptools/py2/setuptools/py31compat.py
@@ -1,32 +1,32 @@
 __all__ = []
-
+ 
 __metaclass__ = type
+ 
 
-
-try:
-    # Python >=3.2
-    from tempfile import TemporaryDirectory
-except ImportError:
-    import shutil
-    import tempfile
+try: 
+    # Python >=3.2 
+    from tempfile import TemporaryDirectory 
+except ImportError: 
+    import shutil 
+    import tempfile 
 
     class TemporaryDirectory:
-        """
-        Very simple temporary directory context manager.
-        Will try to delete afterward, but will also ignore OS and similar
-        errors on deletion.
-        """
+        """ 
+        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):
             self.name = None  # Handle mkdtemp raising an exception
             self.name = tempfile.mkdtemp(**kwargs)
-
-        def __enter__(self):
-            return self.name
-
-        def __exit__(self, exctype, excvalue, exctrace):
-            try:
-                shutil.rmtree(self.name, True)
+ 
+        def __enter__(self): 
+            return self.name 
+ 
+        def __exit__(self, exctype, excvalue, exctrace): 
+            try: 
+                shutil.rmtree(self.name, True) 
             except OSError:  # removal errors are not the only possible
-                pass
-            self.name = None
+                pass 
+            self.name = None 
diff --git a/contrib/python/setuptools/py2/setuptools/sandbox.py b/contrib/python/setuptools/py2/setuptools/sandbox.py
index 685f3f72e3..82822a6cf4 100644
--- a/contrib/python/setuptools/py2/setuptools/sandbox.py
+++ b/contrib/python/setuptools/py2/setuptools/sandbox.py
@@ -1,241 +1,241 @@
-import os
-import sys
-import tempfile
-import operator
-import functools
-import itertools
-import re
-import contextlib
-import pickle
+import os 
+import sys 
+import tempfile 
+import operator 
+import functools 
+import itertools 
+import re 
+import contextlib 
+import pickle 
 import textwrap
-
+ 
 from setuptools.extern import six
 from setuptools.extern.six.moves import builtins, map
-
+ 
 import pkg_resources.py31compat
-
-if sys.platform.startswith('java'):
-    import org.python.modules.posix.PosixModule as _os
-else:
-    _os = sys.modules[os.name]
-try:
-    _file = file
-except NameError:
-    _file = None
-_open = open
-from distutils.errors import DistutilsError
-from pkg_resources import working_set
-
-
-__all__ = [
-    "AbstractSandbox", "DirectorySandbox", "SandboxViolation", "run_setup",
-]
-
-
-def _execfile(filename, globals, locals=None):
-    """
-    Python 3 implementation of execfile.
-    """
-    mode = 'rb'
-    with open(filename, mode) as stream:
-        script = stream.read()
-    if locals is None:
-        locals = globals
-    code = compile(script, filename, 'exec')
-    exec(code, globals, locals)
-
-
-@contextlib.contextmanager
-def save_argv(repl=None):
-    saved = sys.argv[:]
-    if repl is not None:
-        sys.argv[:] = repl
-    try:
-        yield saved
-    finally:
-        sys.argv[:] = saved
-
-
-@contextlib.contextmanager
-def save_path():
-    saved = sys.path[:]
-    try:
-        yield saved
-    finally:
-        sys.path[:] = saved
-
-
-@contextlib.contextmanager
-def override_temp(replacement):
-    """
-    Monkey-patch tempfile.tempdir with replacement, ensuring it exists
-    """
+ 
+if sys.platform.startswith('java'): 
+    import org.python.modules.posix.PosixModule as _os 
+else: 
+    _os = sys.modules[os.name] 
+try: 
+    _file = file 
+except NameError: 
+    _file = None 
+_open = open 
+from distutils.errors import DistutilsError 
+from pkg_resources import working_set 
+ 
+
+__all__ = [ 
+    "AbstractSandbox", "DirectorySandbox", "SandboxViolation", "run_setup", 
+] 
+ 
+
+def _execfile(filename, globals, locals=None): 
+    """ 
+    Python 3 implementation of execfile. 
+    """ 
+    mode = 'rb' 
+    with open(filename, mode) as stream: 
+        script = stream.read() 
+    if locals is None: 
+        locals = globals 
+    code = compile(script, filename, 'exec') 
+    exec(code, globals, locals) 
+ 
+ 
+@contextlib.contextmanager 
+def save_argv(repl=None): 
+    saved = sys.argv[:] 
+    if repl is not None: 
+        sys.argv[:] = repl 
+    try: 
+        yield saved 
+    finally: 
+        sys.argv[:] = saved 
+ 
+ 
+@contextlib.contextmanager 
+def save_path(): 
+    saved = sys.path[:] 
+    try: 
+        yield saved 
+    finally: 
+        sys.path[:] = saved 
+ 
+ 
+@contextlib.contextmanager 
+def override_temp(replacement): 
+    """ 
+    Monkey-patch tempfile.tempdir with replacement, ensuring it exists 
+    """ 
     pkg_resources.py31compat.makedirs(replacement, exist_ok=True)
-
-    saved = tempfile.tempdir
-
-    tempfile.tempdir = replacement
-
-    try:
-        yield
-    finally:
-        tempfile.tempdir = saved
-
-
-@contextlib.contextmanager
-def pushd(target):
-    saved = os.getcwd()
-    os.chdir(target)
-    try:
-        yield saved
-    finally:
-        os.chdir(saved)
-
-
-class UnpickleableException(Exception):
-    """
-    An exception representing another Exception that could not be pickled.
-    """
-
-    @staticmethod
-    def dump(type, exc):
-        """
-        Always return a dumped (pickled) type and exc. If exc can't be pickled,
-        wrap it in UnpickleableException first.
-        """
-        try:
-            return pickle.dumps(type), pickle.dumps(exc)
-        except Exception:
-            # get UnpickleableException inside the sandbox
-            from setuptools.sandbox import UnpickleableException as cls
-            return cls.dump(cls, cls(repr(exc)))
-
-
-class ExceptionSaver:
-    """
-    A Context Manager that will save an exception, serialized, and restore it
-    later.
-    """
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type, exc, tb):
-        if not exc:
-            return
-
-        # dump the exception
-        self._saved = UnpickleableException.dump(type, exc)
-        self._tb = tb
-
-        # suppress the exception
-        return True
-
-    def resume(self):
-        "restore and re-raise any exception"
-
-        if '_saved' not in vars(self):
-            return
-
-        type, exc = map(pickle.loads, self._saved)
-        six.reraise(type, exc, self._tb)
-
-
-@contextlib.contextmanager
-def save_modules():
-    """
-    Context in which imported modules are saved.
-
-    Translates exceptions internal to the context into the equivalent exception
-    outside the context.
-    """
-    saved = sys.modules.copy()
-    with ExceptionSaver() as saved_exc:
-        yield saved
-
-    sys.modules.update(saved)
-    # remove any modules imported since
-    del_modules = (
-        mod_name for mod_name in sys.modules
-        if mod_name not in saved
-        # exclude any encodings modules. See #285
-        and not mod_name.startswith('encodings.')
-    )
-    _clear_modules(del_modules)
-
-    saved_exc.resume()
-
-
-def _clear_modules(module_names):
-    for mod_name in list(module_names):
-        del sys.modules[mod_name]
-
-
-@contextlib.contextmanager
-def save_pkg_resources_state():
-    saved = pkg_resources.__getstate__()
-    try:
-        yield saved
-    finally:
-        pkg_resources.__setstate__(saved)
-
-
-@contextlib.contextmanager
-def setup_context(setup_dir):
-    temp_dir = os.path.join(setup_dir, 'temp')
-    with save_pkg_resources_state():
-        with save_modules():
-            hide_setuptools()
-            with save_path():
-                with save_argv():
-                    with override_temp(temp_dir):
-                        with pushd(setup_dir):
-                            # ensure setuptools commands are available
-                            __import__('setuptools')
-                            yield
-
-
-def _needs_hiding(mod_name):
-    """
-    >>> _needs_hiding('setuptools')
-    True
-    >>> _needs_hiding('pkg_resources')
-    True
-    >>> _needs_hiding('setuptools_plugin')
-    False
-    >>> _needs_hiding('setuptools.__init__')
-    True
-    >>> _needs_hiding('distutils')
-    True
-    >>> _needs_hiding('os')
-    False
-    >>> _needs_hiding('Cython')
-    True
-    """
+ 
+    saved = tempfile.tempdir 
+ 
+    tempfile.tempdir = replacement 
+ 
+    try: 
+        yield 
+    finally: 
+        tempfile.tempdir = saved 
+ 
+ 
+@contextlib.contextmanager 
+def pushd(target): 
+    saved = os.getcwd() 
+    os.chdir(target) 
+    try: 
+        yield saved 
+    finally: 
+        os.chdir(saved) 
+ 
+ 
+class UnpickleableException(Exception): 
+    """ 
+    An exception representing another Exception that could not be pickled. 
+    """ 
+
+    @staticmethod 
+    def dump(type, exc): 
+        """ 
+        Always return a dumped (pickled) type and exc. If exc can't be pickled, 
+        wrap it in UnpickleableException first. 
+        """ 
+        try: 
+            return pickle.dumps(type), pickle.dumps(exc) 
+        except Exception: 
+            # get UnpickleableException inside the sandbox 
+            from setuptools.sandbox import UnpickleableException as cls 
+            return cls.dump(cls, cls(repr(exc))) 
+ 
+ 
+class ExceptionSaver: 
+    """ 
+    A Context Manager that will save an exception, serialized, and restore it 
+    later. 
+    """ 
+
+    def __enter__(self): 
+        return self 
+ 
+    def __exit__(self, type, exc, tb): 
+        if not exc: 
+            return 
+ 
+        # dump the exception 
+        self._saved = UnpickleableException.dump(type, exc) 
+        self._tb = tb 
+ 
+        # suppress the exception 
+        return True 
+ 
+    def resume(self): 
+        "restore and re-raise any exception" 
+ 
+        if '_saved' not in vars(self): 
+            return 
+ 
+        type, exc = map(pickle.loads, self._saved) 
+        six.reraise(type, exc, self._tb) 
+ 
+ 
+@contextlib.contextmanager 
+def save_modules(): 
+    """ 
+    Context in which imported modules are saved. 
+ 
+    Translates exceptions internal to the context into the equivalent exception 
+    outside the context. 
+    """ 
+    saved = sys.modules.copy() 
+    with ExceptionSaver() as saved_exc: 
+        yield saved 
+ 
+    sys.modules.update(saved) 
+    # remove any modules imported since 
+    del_modules = ( 
+        mod_name for mod_name in sys.modules 
+        if mod_name not in saved 
+        # exclude any encodings modules. See #285 
+        and not mod_name.startswith('encodings.') 
+    ) 
+    _clear_modules(del_modules) 
+ 
+    saved_exc.resume() 
+ 
+ 
+def _clear_modules(module_names): 
+    for mod_name in list(module_names): 
+        del sys.modules[mod_name] 
+ 
+ 
+@contextlib.contextmanager 
+def save_pkg_resources_state(): 
+    saved = pkg_resources.__getstate__() 
+    try: 
+        yield saved 
+    finally: 
+        pkg_resources.__setstate__(saved) 
+ 
+ 
+@contextlib.contextmanager 
+def setup_context(setup_dir): 
+    temp_dir = os.path.join(setup_dir, 'temp') 
+    with save_pkg_resources_state(): 
+        with save_modules(): 
+            hide_setuptools() 
+            with save_path(): 
+                with save_argv(): 
+                    with override_temp(temp_dir): 
+                        with pushd(setup_dir): 
+                            # ensure setuptools commands are available 
+                            __import__('setuptools') 
+                            yield 
+ 
+ 
+def _needs_hiding(mod_name): 
+    """ 
+    >>> _needs_hiding('setuptools') 
+    True 
+    >>> _needs_hiding('pkg_resources') 
+    True 
+    >>> _needs_hiding('setuptools_plugin') 
+    False 
+    >>> _needs_hiding('setuptools.__init__') 
+    True 
+    >>> _needs_hiding('distutils') 
+    True 
+    >>> _needs_hiding('os') 
+    False 
+    >>> _needs_hiding('Cython') 
+    True 
+    """ 
     pattern = re.compile(r'(setuptools|pkg_resources|distutils|Cython)(\.|$)')
-    return bool(pattern.match(mod_name))
-
-
-def hide_setuptools():
-    """
-    Remove references to setuptools' modules from sys.modules to allow the
-    invocation to import the most appropriate setuptools. This technique is
-    necessary to avoid issues such as #315 where setuptools upgrading itself
-    would fail to find a function declared in the metadata.
-    """
-    modules = filter(_needs_hiding, sys.modules)
-    _clear_modules(modules)
-
-
-def run_setup(setup_script, args):
-    """Run a distutils setup script, sandboxed in its directory"""
-    setup_dir = os.path.abspath(os.path.dirname(setup_script))
-    with setup_context(setup_dir):
-        try:
+    return bool(pattern.match(mod_name)) 
+ 
+ 
+def hide_setuptools(): 
+    """ 
+    Remove references to setuptools' modules from sys.modules to allow the 
+    invocation to import the most appropriate setuptools. This technique is 
+    necessary to avoid issues such as #315 where setuptools upgrading itself 
+    would fail to find a function declared in the metadata. 
+    """ 
+    modules = filter(_needs_hiding, sys.modules) 
+    _clear_modules(modules) 
+ 
+ 
+def run_setup(setup_script, args): 
+    """Run a distutils setup script, sandboxed in its directory""" 
+    setup_dir = os.path.abspath(os.path.dirname(setup_script)) 
+    with setup_context(setup_dir): 
+        try: 
             sys.argv[:] = [setup_script] + list(args)
-            sys.path.insert(0, setup_dir)
-            # reset to include setup dir, w/clean callback list
-            working_set.__init__()
+            sys.path.insert(0, setup_dir) 
+            # reset to include setup dir, w/clean callback list 
+            working_set.__init__() 
             working_set.callbacks.append(lambda dist: dist.activate())
 
             # __file__ should be a byte string on Python 2 (#712)
@@ -247,28 +247,28 @@ def run_setup(setup_script, args):
 
             with DirectorySandbox(setup_dir):
                 ns = dict(__file__=dunder_file, __name__='__main__')
-                _execfile(setup_script, ns)
-        except SystemExit as v:
-            if v.args and v.args[0]:
-                raise
-            # Normal exit, just return
-
-
-class AbstractSandbox:
-    """Wrap 'os' module and 'open()' builtin for virtualizing setup scripts"""
-
-    _active = False
-
-    def __init__(self):
-        self._attrs = [
-            name for name in dir(_os)
+                _execfile(setup_script, ns) 
+        except SystemExit as v: 
+            if v.args and v.args[0]: 
+                raise 
+            # Normal exit, just return 
+ 
+ 
+class AbstractSandbox: 
+    """Wrap 'os' module and 'open()' builtin for virtualizing setup scripts""" 
+ 
+    _active = False 
+ 
+    def __init__(self): 
+        self._attrs = [ 
+            name for name in dir(_os) 
             if not name.startswith('_') and hasattr(self, name)
-        ]
-
-    def _copy(self, source):
-        for name in self._attrs:
+        ] 
+ 
+    def _copy(self, source): 
+        for name in self._attrs: 
             setattr(os, name, getattr(source, name))
-
+ 
     def __enter__(self):
         self._copy(self)
         if _file:
@@ -283,209 +283,209 @@ class AbstractSandbox:
         builtins.open = _open
         self._copy(_os)
 
-    def run(self, func):
-        """Run 'func' under os sandboxing"""
+    def run(self, func): 
+        """Run 'func' under os sandboxing""" 
         with self:
-            return func()
-
-    def _mk_dual_path_wrapper(name):
+            return func() 
+ 
+    def _mk_dual_path_wrapper(name): 
         original = getattr(_os, name)
 
         def wrap(self, src, dst, *args, **kw):
-            if self._active:
+            if self._active: 
                 src, dst = self._remap_pair(name, src, dst, *args, **kw)
             return original(src, dst, *args, **kw)
 
-        return wrap
-
-    for name in ["rename", "link", "symlink"]:
+        return wrap 
+ 
+    for name in ["rename", "link", "symlink"]: 
         if hasattr(_os, name):
             locals()[name] = _mk_dual_path_wrapper(name)
-
-    def _mk_single_path_wrapper(name, original=None):
+ 
+    def _mk_single_path_wrapper(name, original=None): 
         original = original or getattr(_os, name)
 
         def wrap(self, path, *args, **kw):
-            if self._active:
+            if self._active: 
                 path = self._remap_input(name, path, *args, **kw)
             return original(path, *args, **kw)
 
-        return wrap
-
-    if _file:
-        _file = _mk_single_path_wrapper('file', _file)
-    _open = _mk_single_path_wrapper('open', _open)
-    for name in [
-        "stat", "listdir", "chdir", "open", "chmod", "chown", "mkdir",
-        "remove", "unlink", "rmdir", "utime", "lchown", "chroot", "lstat",
-        "startfile", "mkfifo", "mknod", "pathconf", "access"
-    ]:
+        return wrap 
+ 
+    if _file: 
+        _file = _mk_single_path_wrapper('file', _file) 
+    _open = _mk_single_path_wrapper('open', _open) 
+    for name in [ 
+        "stat", "listdir", "chdir", "open", "chmod", "chown", "mkdir", 
+        "remove", "unlink", "rmdir", "utime", "lchown", "chroot", "lstat", 
+        "startfile", "mkfifo", "mknod", "pathconf", "access" 
+    ]: 
         if hasattr(_os, name):
             locals()[name] = _mk_single_path_wrapper(name)
-
-    def _mk_single_with_return(name):
+ 
+    def _mk_single_with_return(name): 
         original = getattr(_os, name)
 
         def wrap(self, path, *args, **kw):
-            if self._active:
+            if self._active: 
                 path = self._remap_input(name, path, *args, **kw)
                 return self._remap_output(name, original(path, *args, **kw))
             return original(path, *args, **kw)
 
-        return wrap
-
-    for name in ['readlink', 'tempnam']:
+        return wrap 
+ 
+    for name in ['readlink', 'tempnam']: 
         if hasattr(_os, name):
             locals()[name] = _mk_single_with_return(name)
-
-    def _mk_query(name):
+ 
+    def _mk_query(name): 
         original = getattr(_os, name)
 
         def wrap(self, *args, **kw):
             retval = original(*args, **kw)
-            if self._active:
-                return self._remap_output(name, retval)
-            return retval
+            if self._active: 
+                return self._remap_output(name, retval) 
+            return retval 
 
-        return wrap
-
-    for name in ['getcwd', 'tmpnam']:
+        return wrap 
+ 
+    for name in ['getcwd', 'tmpnam']: 
         if hasattr(_os, name):
             locals()[name] = _mk_query(name)
-
+ 
     def _validate_path(self, path):
-        """Called to remap or validate any path, whether input or output"""
-        return path
-
+        """Called to remap or validate any path, whether input or output""" 
+        return path 
+ 
     def _remap_input(self, operation, path, *args, **kw):
-        """Called for path inputs"""
-        return self._validate_path(path)
-
+        """Called for path inputs""" 
+        return self._validate_path(path) 
+ 
     def _remap_output(self, operation, path):
-        """Called for path outputs"""
-        return self._validate_path(path)
-
+        """Called for path outputs""" 
+        return self._validate_path(path) 
+ 
     def _remap_pair(self, operation, src, dst, *args, **kw):
-        """Called for path pairs like rename, link, and symlink operations"""
-        return (
+        """Called for path pairs like rename, link, and symlink operations""" 
+        return ( 
             self._remap_input(operation + '-from', src, *args, **kw),
             self._remap_input(operation + '-to', dst, *args, **kw)
-        )
-
-
-if hasattr(os, 'devnull'):
-    _EXCEPTIONS = [os.devnull,]
-else:
-    _EXCEPTIONS = []
-
-
-class DirectorySandbox(AbstractSandbox):
-    """Restrict operations to a single subdirectory - pseudo-chroot"""
-
-    write_ops = dict.fromkeys([
-        "open", "chmod", "chown", "mkdir", "remove", "unlink", "rmdir",
-        "utime", "lchown", "chroot", "mkfifo", "mknod", "tempnam",
-    ])
-
-    _exception_patterns = [
-        # Allow lib2to3 to attempt to save a pickled grammar object (#121)
+        ) 
+ 
+ 
+if hasattr(os, 'devnull'): 
+    _EXCEPTIONS = [os.devnull,] 
+else: 
+    _EXCEPTIONS = [] 
+ 
+ 
+class DirectorySandbox(AbstractSandbox): 
+    """Restrict operations to a single subdirectory - pseudo-chroot""" 
+ 
+    write_ops = dict.fromkeys([ 
+        "open", "chmod", "chown", "mkdir", "remove", "unlink", "rmdir", 
+        "utime", "lchown", "chroot", "mkfifo", "mknod", "tempnam", 
+    ]) 
+ 
+    _exception_patterns = [ 
+        # Allow lib2to3 to attempt to save a pickled grammar object (#121) 
         r'.*lib2to3.*\.pickle$',
-    ]
-    "exempt writing to paths that match the pattern"
-
-    def __init__(self, sandbox, exceptions=_EXCEPTIONS):
-        self._sandbox = os.path.normcase(os.path.realpath(sandbox))
+    ] 
+    "exempt writing to paths that match the pattern" 
+ 
+    def __init__(self, sandbox, exceptions=_EXCEPTIONS): 
+        self._sandbox = os.path.normcase(os.path.realpath(sandbox)) 
         self._prefix = os.path.join(self._sandbox, '')
-        self._exceptions = [
-            os.path.normcase(os.path.realpath(path))
-            for path in exceptions
-        ]
-        AbstractSandbox.__init__(self)
-
-    def _violation(self, operation, *args, **kw):
-        from setuptools.sandbox import SandboxViolation
-        raise SandboxViolation(operation, args, kw)
-
-    if _file:
-
-        def _file(self, path, mode='r', *args, **kw):
-            if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
-                self._violation("file", path, mode, *args, **kw)
+        self._exceptions = [ 
+            os.path.normcase(os.path.realpath(path)) 
+            for path in exceptions 
+        ] 
+        AbstractSandbox.__init__(self) 
+ 
+    def _violation(self, operation, *args, **kw): 
+        from setuptools.sandbox import SandboxViolation 
+        raise SandboxViolation(operation, args, kw) 
+ 
+    if _file: 
+
+        def _file(self, path, mode='r', *args, **kw): 
+            if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path): 
+                self._violation("file", path, mode, *args, **kw) 
             return _file(path, mode, *args, **kw)
-
-    def _open(self, path, mode='r', *args, **kw):
-        if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
-            self._violation("open", path, mode, *args, **kw)
+ 
+    def _open(self, path, mode='r', *args, **kw): 
+        if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path): 
+            self._violation("open", path, mode, *args, **kw) 
         return _open(path, mode, *args, **kw)
-
-    def tmpnam(self):
-        self._violation("tmpnam")
-
-    def _ok(self, path):
-        active = self._active
-        try:
-            self._active = False
-            realpath = os.path.normcase(os.path.realpath(path))
-            return (
-                self._exempted(realpath)
-                or realpath == self._sandbox
-                or realpath.startswith(self._prefix)
-            )
-        finally:
-            self._active = active
-
-    def _exempted(self, filepath):
-        start_matches = (
-            filepath.startswith(exception)
-            for exception in self._exceptions
-        )
-        pattern_matches = (
-            re.match(pattern, filepath)
-            for pattern in self._exception_patterns
-        )
-        candidates = itertools.chain(start_matches, pattern_matches)
-        return any(candidates)
-
-    def _remap_input(self, operation, path, *args, **kw):
-        """Called for path inputs"""
-        if operation in self.write_ops and not self._ok(path):
-            self._violation(operation, os.path.realpath(path), *args, **kw)
-        return path
-
-    def _remap_pair(self, operation, src, dst, *args, **kw):
-        """Called for path pairs like rename, link, and symlink operations"""
-        if not self._ok(src) or not self._ok(dst):
-            self._violation(operation, src, dst, *args, **kw)
+ 
+    def tmpnam(self): 
+        self._violation("tmpnam") 
+ 
+    def _ok(self, path): 
+        active = self._active 
+        try: 
+            self._active = False 
+            realpath = os.path.normcase(os.path.realpath(path)) 
+            return ( 
+                self._exempted(realpath) 
+                or realpath == self._sandbox 
+                or realpath.startswith(self._prefix) 
+            ) 
+        finally: 
+            self._active = active 
+ 
+    def _exempted(self, filepath): 
+        start_matches = ( 
+            filepath.startswith(exception) 
+            for exception in self._exceptions 
+        ) 
+        pattern_matches = ( 
+            re.match(pattern, filepath) 
+            for pattern in self._exception_patterns 
+        ) 
+        candidates = itertools.chain(start_matches, pattern_matches) 
+        return any(candidates) 
+ 
+    def _remap_input(self, operation, path, *args, **kw): 
+        """Called for path inputs""" 
+        if operation in self.write_ops and not self._ok(path): 
+            self._violation(operation, os.path.realpath(path), *args, **kw) 
+        return path 
+ 
+    def _remap_pair(self, operation, src, dst, *args, **kw): 
+        """Called for path pairs like rename, link, and symlink operations""" 
+        if not self._ok(src) or not self._ok(dst): 
+            self._violation(operation, src, dst, *args, **kw) 
         return (src, dst)
-
-    def open(self, file, flags, mode=0o777, *args, **kw):
-        """Called for low-level os.open()"""
-        if flags & WRITE_FLAGS and not self._ok(file):
-            self._violation("os.open", file, flags, mode, *args, **kw)
+ 
+    def open(self, file, flags, mode=0o777, *args, **kw): 
+        """Called for low-level os.open()""" 
+        if flags & WRITE_FLAGS and not self._ok(file): 
+            self._violation("os.open", file, flags, mode, *args, **kw) 
         return _os.open(file, flags, mode, *args, **kw)
+ 
 
+WRITE_FLAGS = functools.reduce( 
+    operator.or_, [getattr(_os, a, 0) for a in 
+        "O_WRONLY O_RDWR O_APPEND O_CREAT O_TRUNC O_TEMPORARY".split()] 
+) 
+ 
 
-WRITE_FLAGS = functools.reduce(
-    operator.or_, [getattr(_os, a, 0) for a in
-        "O_WRONLY O_RDWR O_APPEND O_CREAT O_TRUNC O_TEMPORARY".split()]
-)
-
-
-class SandboxViolation(DistutilsError):
-    """A setup script attempted to modify the filesystem outside the sandbox"""
-
+class SandboxViolation(DistutilsError): 
+    """A setup script attempted to modify the filesystem outside the sandbox""" 
+ 
     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.
-
+ 
         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())
diff --git a/contrib/python/setuptools/py2/setuptools/script.tmpl b/contrib/python/setuptools/py2/setuptools/script.tmpl
index ff5efbcab3..df8f68d6b4 100644
--- a/contrib/python/setuptools/py2/setuptools/script.tmpl
+++ b/contrib/python/setuptools/py2/setuptools/script.tmpl
@@ -1,3 +1,3 @@
-# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r
-__requires__ = %(spec)r
-__import__('pkg_resources').run_script(%(spec)r, %(script_name)r)
+# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r 
+__requires__ = %(spec)r 
+__import__('pkg_resources').run_script(%(spec)r, %(script_name)r) 
diff --git a/contrib/python/setuptools/py2/setuptools/site-patch.py b/contrib/python/setuptools/py2/setuptools/site-patch.py
index 40b00de0a7..16e75879fd 100644
--- a/contrib/python/setuptools/py2/setuptools/site-patch.py
+++ b/contrib/python/setuptools/py2/setuptools/site-patch.py
@@ -1,74 +1,74 @@
-def __boot():
-    import sys
-    import os
-    PYTHONPATH = os.environ.get('PYTHONPATH')
+def __boot(): 
+    import sys 
+    import os 
+    PYTHONPATH = os.environ.get('PYTHONPATH') 
     if PYTHONPATH is None or (sys.platform == 'win32' and not PYTHONPATH):
-        PYTHONPATH = []
-    else:
-        PYTHONPATH = PYTHONPATH.split(os.pathsep)
-
+        PYTHONPATH = [] 
+    else: 
+        PYTHONPATH = PYTHONPATH.split(os.pathsep) 
+ 
     pic = getattr(sys, 'path_importer_cache', {})
-    stdpath = sys.path[len(PYTHONPATH):]
-    mydir = os.path.dirname(__file__)
-
-    for item in stdpath:
+    stdpath = sys.path[len(PYTHONPATH):] 
+    mydir = os.path.dirname(__file__) 
+ 
+    for item in stdpath: 
         if item == mydir or not item:
             continue  # skip if current dir. on Windows, or my own directory
-        importer = pic.get(item)
-        if importer is not None:
-            loader = importer.find_module('site')
-            if loader is not None:
-                # This should actually reload the current module
-                loader.load_module('site')
-                break
-        else:
-            try:
+        importer = pic.get(item) 
+        if importer is not None: 
+            loader = importer.find_module('site') 
+            if loader is not None: 
+                # This should actually reload the current module 
+                loader.load_module('site') 
+                break 
+        else: 
+            try: 
                 import imp  # Avoid import loop in Python 3
                 stream, path, descr = imp.find_module('site', [item])
-            except ImportError:
-                continue
-            if stream is None:
-                continue
-            try:
-                # This should actually reload the current module
+            except ImportError: 
+                continue 
+            if stream is None: 
+                continue 
+            try: 
+                # This should actually reload the current module 
                 imp.load_module('site', stream, path, descr)
-            finally:
-                stream.close()
-            break
-    else:
-        raise ImportError("Couldn't find the real 'site' module")
-
+            finally: 
+                stream.close() 
+            break 
+    else: 
+        raise ImportError("Couldn't find the real 'site' module") 
+ 
     known_paths = dict([(makepath(item)[1], 1) for item in sys.path])  # 2.2 comp
-
+ 
     oldpos = getattr(sys, '__egginsert', 0)  # save old insertion position
     sys.__egginsert = 0  # and reset the current one
-
-    for item in PYTHONPATH:
-        addsitedir(item)
-
+ 
+    for item in PYTHONPATH: 
+        addsitedir(item) 
+ 
     sys.__egginsert += oldpos  # restore effective old position
-
-    d, nd = makepath(stdpath[0])
-    insert_at = None
-    new_path = []
-
-    for item in sys.path:
-        p, np = makepath(item)
-
+ 
+    d, nd = makepath(stdpath[0]) 
+    insert_at = None 
+    new_path = [] 
+ 
+    for item in sys.path: 
+        p, np = makepath(item) 
+ 
         if np == nd and insert_at is None:
-            # We've hit the first 'system' path entry, so added entries go here
-            insert_at = len(new_path)
-
-        if np in known_paths or insert_at is None:
-            new_path.append(item)
-        else:
-            # new path after the insert point, back-insert it
-            new_path.insert(insert_at, item)
-            insert_at += 1
-
-    sys.path[:] = new_path
-
+            # We've hit the first 'system' path entry, so added entries go here 
+            insert_at = len(new_path) 
+ 
+        if np in known_paths or insert_at is None: 
+            new_path.append(item) 
+        else: 
+            # new path after the insert point, back-insert it 
+            new_path.insert(insert_at, item) 
+            insert_at += 1 
+ 
+    sys.path[:] = new_path 
+ 
 
 if __name__ == 'site':
-    __boot()
-    del __boot
+    __boot() 
+    del __boot 
diff --git a/contrib/python/setuptools/py2/setuptools/ssl_support.py b/contrib/python/setuptools/py2/setuptools/ssl_support.py
index 226db694bb..7f5aa7f577 100644
--- a/contrib/python/setuptools/py2/setuptools/ssl_support.py
+++ b/contrib/python/setuptools/py2/setuptools/ssl_support.py
@@ -1,191 +1,191 @@
-import os
-import socket
-import atexit
-import re
+import os 
+import socket 
+import atexit 
+import re 
 import functools
-
+ 
 from setuptools.extern.six.moves import urllib, http_client, map, filter
-
-from pkg_resources import ResolutionError, ExtractionError
-
-try:
-    import ssl
-except ImportError:
-    ssl = None
-
-__all__ = [
-    'VerifyingHTTPSHandler', 'find_ca_bundle', 'is_available', 'cert_paths',
-    'opener_for'
-]
-
-cert_paths = """
-/etc/pki/tls/certs/ca-bundle.crt
-/etc/ssl/certs/ca-certificates.crt
-/usr/share/ssl/certs/ca-bundle.crt
-/usr/local/share/certs/ca-root.crt
-/etc/ssl/cert.pem
-/System/Library/OpenSSL/certs/cert.pem
-/usr/local/share/certs/ca-root-nss.crt
+ 
+from pkg_resources import ResolutionError, ExtractionError 
+ 
+try: 
+    import ssl 
+except ImportError: 
+    ssl = None 
+ 
+__all__ = [ 
+    'VerifyingHTTPSHandler', 'find_ca_bundle', 'is_available', 'cert_paths', 
+    'opener_for' 
+] 
+ 
+cert_paths = """ 
+/etc/pki/tls/certs/ca-bundle.crt 
+/etc/ssl/certs/ca-certificates.crt 
+/usr/share/ssl/certs/ca-bundle.crt 
+/usr/local/share/certs/ca-root.crt 
+/etc/ssl/cert.pem 
+/System/Library/OpenSSL/certs/cert.pem 
+/usr/local/share/certs/ca-root-nss.crt 
 /etc/ssl/ca-bundle.pem
-""".strip().split()
-
-try:
-    HTTPSHandler = urllib.request.HTTPSHandler
-    HTTPSConnection = http_client.HTTPSConnection
-except AttributeError:
-    HTTPSHandler = HTTPSConnection = object
-
-is_available = ssl is not None and object not in (HTTPSHandler, HTTPSConnection)
-
-
-try:
-    from ssl import CertificateError, match_hostname
-except ImportError:
-    try:
-        from backports.ssl_match_hostname import CertificateError
-        from backports.ssl_match_hostname import match_hostname
-    except ImportError:
-        CertificateError = None
-        match_hostname = None
-
-if not CertificateError:
-
-    class CertificateError(ValueError):
-        pass
-
-
-if not match_hostname:
-
-    def _dnsname_match(dn, hostname, max_wildcards=1):
-        """Matching according to RFC 6125, section 6.4.3
-
+""".strip().split() 
+ 
+try: 
+    HTTPSHandler = urllib.request.HTTPSHandler 
+    HTTPSConnection = http_client.HTTPSConnection 
+except AttributeError: 
+    HTTPSHandler = HTTPSConnection = object 
+ 
+is_available = ssl is not None and object not in (HTTPSHandler, HTTPSConnection) 
+ 
+ 
+try: 
+    from ssl import CertificateError, match_hostname 
+except ImportError: 
+    try: 
+        from backports.ssl_match_hostname import CertificateError 
+        from backports.ssl_match_hostname import match_hostname 
+    except ImportError: 
+        CertificateError = None 
+        match_hostname = None 
+ 
+if not CertificateError: 
+
+    class CertificateError(ValueError): 
+        pass 
+ 
+
+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
-        """
-        pats = []
-        if not dn:
-            return False
-
-        # Ported from python3-syntax:
-        # leftmost, *remainder = dn.split(r'.')
-        parts = dn.split(r'.')
-        leftmost = parts[0]
-        remainder = parts[1:]
-
-        wildcards = leftmost.count('*')
-        if wildcards > max_wildcards:
-            # Issue #17980: avoid denials of service by refusing more
-            # than one wildcard per fragment.  A survey of established
-            # policy among SSL implementations showed it to be a
-            # reasonable choice.
-            raise CertificateError(
-                "too many wildcards in certificate DNS name: " + repr(dn))
-
-        # speed up common case w/o wildcards
-        if not wildcards:
-            return dn.lower() == hostname.lower()
-
-        # RFC 6125, section 6.4.3, subitem 1.
-        # The client SHOULD NOT attempt to match a presented identifier in which
-        # the wildcard character comprises a label other than the left-most label.
-        if leftmost == '*':
-            # When '*' is a fragment by itself, it matches a non-empty dotless
-            # fragment.
-            pats.append('[^.]+')
-        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
-            # RFC 6125, section 6.4.3, subitem 3.
-            # The client SHOULD NOT attempt to match a presented identifier
-            # where the wildcard character is embedded within an A-label or
-            # U-label of an internationalized domain name.
-            pats.append(re.escape(leftmost))
-        else:
-            # Otherwise, '*' matches any dotless string, e.g. www*
-            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
-
-        # add the remaining fragments, ignore any wildcards
-        for frag in remainder:
-            pats.append(re.escape(frag))
-
-        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
-        return pat.match(hostname)
-
-    def match_hostname(cert, hostname):
-        """Verify that *cert* (in decoded format as returned by
-        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
-        rules are followed, but IP addresses are not accepted for *hostname*.
-
-        CertificateError is raised on failure. On success, the function
-        returns nothing.
-        """
-        if not cert:
-            raise ValueError("empty or no certificate")
-        dnsnames = []
-        san = cert.get('subjectAltName', ())
-        for key, value in san:
-            if key == 'DNS':
-                if _dnsname_match(value, hostname):
-                    return
-                dnsnames.append(value)
-        if not dnsnames:
-            # The subject is only checked when there is no dNSName entry
-            # in subjectAltName
-            for sub in cert.get('subject', ()):
-                for key, value in sub:
-                    # XXX according to RFC 2818, the most specific Common Name
-                    # must be used.
-                    if key == 'commonName':
-                        if _dnsname_match(value, hostname):
-                            return
-                        dnsnames.append(value)
-        if len(dnsnames) > 1:
-            raise CertificateError("hostname %r "
-                "doesn't match either of %s"
-                % (hostname, ', '.join(map(repr, dnsnames))))
-        elif len(dnsnames) == 1:
-            raise CertificateError("hostname %r "
-                "doesn't match %r"
-                % (hostname, dnsnames[0]))
-        else:
-            raise CertificateError("no appropriate commonName or "
-                "subjectAltName fields were found")
-
-
-class VerifyingHTTPSHandler(HTTPSHandler):
-    """Simple verifying handler: no auth, subclasses, timeouts, etc."""
-
-    def __init__(self, ca_bundle):
-        self.ca_bundle = ca_bundle
-        HTTPSHandler.__init__(self)
-
-    def https_open(self, req):
-        return self.do_open(
-            lambda host, **kw: VerifyingHTTPSConn(host, self.ca_bundle, **kw), req
-        )
-
-
-class VerifyingHTTPSConn(HTTPSConnection):
-    """Simple verifying connection: no auth, subclasses, timeouts, etc."""
-
-    def __init__(self, host, ca_bundle, **kw):
-        HTTPSConnection.__init__(self, host, **kw)
-        self.ca_bundle = ca_bundle
-
-    def connect(self):
-        sock = socket.create_connection(
-            (self.host, self.port), getattr(self, 'source_address', None)
-        )
-
-        # Handle the socket if a (proxy) tunnel is present
-        if hasattr(self, '_tunnel') and getattr(self, '_tunnel_host', None):
-            self.sock = sock
-            self._tunnel()
-            # http://bugs.python.org/issue7776: Python>=3.4.1 and >=2.7.7
-            # change self.host to mean the proxy server host when tunneling is
-            # being used. Adapt, since we are interested in the destination
-            # host for the match_hostname() comparison.
-            actual_host = self._tunnel_host
-        else:
-            actual_host = self.host
-
+        """ 
+        pats = [] 
+        if not dn: 
+            return False 
+ 
+        # Ported from python3-syntax: 
+        # leftmost, *remainder = dn.split(r'.') 
+        parts = dn.split(r'.') 
+        leftmost = parts[0] 
+        remainder = parts[1:] 
+ 
+        wildcards = leftmost.count('*') 
+        if wildcards > max_wildcards: 
+            # Issue #17980: avoid denials of service by refusing more 
+            # than one wildcard per fragment.  A survey of established 
+            # policy among SSL implementations showed it to be a 
+            # reasonable choice. 
+            raise CertificateError( 
+                "too many wildcards in certificate DNS name: " + repr(dn)) 
+ 
+        # speed up common case w/o wildcards 
+        if not wildcards: 
+            return dn.lower() == hostname.lower() 
+ 
+        # RFC 6125, section 6.4.3, subitem 1. 
+        # The client SHOULD NOT attempt to match a presented identifier in which 
+        # the wildcard character comprises a label other than the left-most label. 
+        if leftmost == '*': 
+            # When '*' is a fragment by itself, it matches a non-empty dotless 
+            # fragment. 
+            pats.append('[^.]+') 
+        elif leftmost.startswith('xn--') or hostname.startswith('xn--'): 
+            # RFC 6125, section 6.4.3, subitem 3. 
+            # The client SHOULD NOT attempt to match a presented identifier 
+            # where the wildcard character is embedded within an A-label or 
+            # U-label of an internationalized domain name. 
+            pats.append(re.escape(leftmost)) 
+        else: 
+            # Otherwise, '*' matches any dotless string, e.g. www* 
+            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*')) 
+ 
+        # add the remaining fragments, ignore any wildcards 
+        for frag in remainder: 
+            pats.append(re.escape(frag)) 
+ 
+        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE) 
+        return pat.match(hostname) 
+ 
+    def match_hostname(cert, hostname): 
+        """Verify that *cert* (in decoded format as returned by 
+        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125 
+        rules are followed, but IP addresses are not accepted for *hostname*. 
+ 
+        CertificateError is raised on failure. On success, the function 
+        returns nothing. 
+        """ 
+        if not cert: 
+            raise ValueError("empty or no certificate") 
+        dnsnames = [] 
+        san = cert.get('subjectAltName', ()) 
+        for key, value in san: 
+            if key == 'DNS': 
+                if _dnsname_match(value, hostname): 
+                    return 
+                dnsnames.append(value) 
+        if not dnsnames: 
+            # The subject is only checked when there is no dNSName entry 
+            # in subjectAltName 
+            for sub in cert.get('subject', ()): 
+                for key, value in sub: 
+                    # XXX according to RFC 2818, the most specific Common Name 
+                    # must be used. 
+                    if key == 'commonName': 
+                        if _dnsname_match(value, hostname): 
+                            return 
+                        dnsnames.append(value) 
+        if len(dnsnames) > 1: 
+            raise CertificateError("hostname %r " 
+                "doesn't match either of %s" 
+                % (hostname, ', '.join(map(repr, dnsnames)))) 
+        elif len(dnsnames) == 1: 
+            raise CertificateError("hostname %r " 
+                "doesn't match %r" 
+                % (hostname, dnsnames[0])) 
+        else: 
+            raise CertificateError("no appropriate commonName or " 
+                "subjectAltName fields were found") 
+ 
+ 
+class VerifyingHTTPSHandler(HTTPSHandler): 
+    """Simple verifying handler: no auth, subclasses, timeouts, etc.""" 
+ 
+    def __init__(self, ca_bundle): 
+        self.ca_bundle = ca_bundle 
+        HTTPSHandler.__init__(self) 
+ 
+    def https_open(self, req): 
+        return self.do_open( 
+            lambda host, **kw: VerifyingHTTPSConn(host, self.ca_bundle, **kw), req 
+        ) 
+ 
+ 
+class VerifyingHTTPSConn(HTTPSConnection): 
+    """Simple verifying connection: no auth, subclasses, timeouts, etc.""" 
+
+    def __init__(self, host, ca_bundle, **kw): 
+        HTTPSConnection.__init__(self, host, **kw) 
+        self.ca_bundle = ca_bundle 
+ 
+    def connect(self): 
+        sock = socket.create_connection( 
+            (self.host, self.port), getattr(self, 'source_address', None) 
+        ) 
+ 
+        # Handle the socket if a (proxy) tunnel is present 
+        if hasattr(self, '_tunnel') and getattr(self, '_tunnel_host', None): 
+            self.sock = sock 
+            self._tunnel() 
+            # http://bugs.python.org/issue7776: Python>=3.4.1 and >=2.7.7 
+            # change self.host to mean the proxy server host when tunneling is 
+            # being used. Adapt, since we are interested in the destination 
+            # host for the match_hostname() comparison. 
+            actual_host = self._tunnel_host 
+        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)
@@ -194,21 +194,21 @@ class VerifyingHTTPSConn(HTTPSConnection):
             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:
-            self.sock.shutdown(socket.SHUT_RDWR)
-            self.sock.close()
-            raise
-
-
-def opener_for(ca_bundle=None):
-    """Get a urlopen() replacement that uses ca_bundle for verification"""
-    return urllib.request.build_opener(
-        VerifyingHTTPSHandler(ca_bundle or find_ca_bundle())
-    ).open
-
-
+        try: 
+            match_hostname(self.sock.getpeercert(), actual_host) 
+        except CertificateError: 
+            self.sock.shutdown(socket.SHUT_RDWR) 
+            self.sock.close() 
+            raise 
+ 
+
+def opener_for(ca_bundle=None): 
+    """Get a urlopen() replacement that uses ca_bundle for verification""" 
+    return urllib.request.build_opener( 
+        VerifyingHTTPSHandler(ca_bundle or find_ca_bundle()) 
+    ).open 
+ 
+ 
 # from jaraco.functools
 def once(func):
     @functools.wraps(func)
@@ -217,34 +217,34 @@ def once(func):
             func.always_returns = func(*args, **kwargs)
         return func.always_returns
     return wrapper
-
+ 
 
 @once
-def get_win_certfile():
-    try:
+def get_win_certfile(): 
+    try: 
         import wincertstore
-    except ImportError:
-        return None
-
+    except ImportError: 
+        return None 
+ 
     class CertFile(wincertstore.CertFile):
         def __init__(self):
             super(CertFile, self).__init__()
-            atexit.register(self.close)
-
-        def close(self):
-            try:
+            atexit.register(self.close) 
+ 
+        def close(self): 
+            try: 
                 super(CertFile, self).close()
-            except OSError:
-                pass
-
+            except OSError: 
+                pass 
+ 
     _wincerts = CertFile()
     _wincerts.addstore('CA')
     _wincerts.addstore('ROOT')
-    return _wincerts.name
-
-
-def find_ca_bundle():
-    """Return an existing CA bundle path, or None"""
+    return _wincerts.name 
+ 
+ 
+def find_ca_bundle(): 
+    """Return an existing CA bundle path, or None""" 
     extant_cert_paths = filter(os.path.isfile, cert_paths)
     return (
         get_win_certfile()
@@ -254,7 +254,7 @@ def find_ca_bundle():
 
 
 def _certifi_where():
-    try:
+    try: 
         return __import__('certifi').where()
-    except (ImportError, ResolutionError, ExtractionError):
+    except (ImportError, ResolutionError, ExtractionError): 
         pass
diff --git a/contrib/python/setuptools/py2/setuptools/unicode_utils.py b/contrib/python/setuptools/py2/setuptools/unicode_utils.py
index 7c63efd20b..9128c79f74 100644
--- a/contrib/python/setuptools/py2/setuptools/unicode_utils.py
+++ b/contrib/python/setuptools/py2/setuptools/unicode_utils.py
@@ -1,44 +1,44 @@
-import unicodedata
-import sys
-
+import unicodedata 
+import sys 
+ 
 from setuptools.extern import six
-
-
-# HFS Plus uses decomposed UTF-8
-def decompose(path):
-    if isinstance(path, six.text_type):
-        return unicodedata.normalize('NFD', path)
-    try:
-        path = path.decode('utf-8')
-        path = unicodedata.normalize('NFD', path)
-        path = path.encode('utf-8')
-    except UnicodeError:
-        pass  # Not UTF-8
-    return path
-
-
-def filesys_decode(path):
-    """
-    Ensure that the given path is decoded,
-    NONE when no expected encoding works
-    """
-
-    if isinstance(path, six.text_type):
-        return path
-
-    fs_enc = sys.getfilesystemencoding() or 'utf-8'
-    candidates = fs_enc, 'utf-8'
-
-    for enc in candidates:
-        try:
-            return path.decode(enc)
-        except UnicodeDecodeError:
-            continue
-
-
-def try_encode(string, enc):
-    "turn unicode encoding into a functional routine"
-    try:
-        return string.encode(enc)
-    except UnicodeEncodeError:
-        return None
+ 
+
+# HFS Plus uses decomposed UTF-8 
+def decompose(path): 
+    if isinstance(path, six.text_type): 
+        return unicodedata.normalize('NFD', path) 
+    try: 
+        path = path.decode('utf-8') 
+        path = unicodedata.normalize('NFD', path) 
+        path = path.encode('utf-8') 
+    except UnicodeError: 
+        pass  # Not UTF-8 
+    return path 
+ 
+ 
+def filesys_decode(path): 
+    """ 
+    Ensure that the given path is decoded, 
+    NONE when no expected encoding works 
+    """ 
+ 
+    if isinstance(path, six.text_type): 
+        return path 
+ 
+    fs_enc = sys.getfilesystemencoding() or 'utf-8' 
+    candidates = fs_enc, 'utf-8' 
+ 
+    for enc in candidates: 
+        try: 
+            return path.decode(enc) 
+        except UnicodeDecodeError: 
+            continue 
+ 
+ 
+def try_encode(string, enc): 
+    "turn unicode encoding into a functional routine" 
+    try: 
+        return string.encode(enc) 
+    except UnicodeEncodeError: 
+        return None 
diff --git a/contrib/python/setuptools/py2/setuptools/windows_support.py b/contrib/python/setuptools/py2/setuptools/windows_support.py
index cb977cff95..a4a389fede 100644
--- a/contrib/python/setuptools/py2/setuptools/windows_support.py
+++ b/contrib/python/setuptools/py2/setuptools/windows_support.py
@@ -1,29 +1,29 @@
-import platform
-import ctypes
-
-
-def windows_only(func):
-    if platform.system() != 'Windows':
-        return lambda *args, **kwargs: None
-    return func
-
-
-@windows_only
-def hide_file(path):
-    """
-    Set the hidden attribute on a file or directory.
-
-    From http://stackoverflow.com/questions/19622133/
-
-    `path` must be text.
-    """
-    __import__('ctypes.wintypes')
-    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
-    SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD
-    SetFileAttributes.restype = ctypes.wintypes.BOOL
-
-    FILE_ATTRIBUTE_HIDDEN = 0x02
-
-    ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN)
-    if not ret:
-        raise ctypes.WinError()
+import platform 
+import ctypes 
+ 
+ 
+def windows_only(func): 
+    if platform.system() != 'Windows': 
+        return lambda *args, **kwargs: None 
+    return func 
+ 
+ 
+@windows_only 
+def hide_file(path): 
+    """ 
+    Set the hidden attribute on a file or directory. 
+ 
+    From http://stackoverflow.com/questions/19622133/ 
+ 
+    `path` must be text. 
+    """ 
+    __import__('ctypes.wintypes') 
+    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW 
+    SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD 
+    SetFileAttributes.restype = ctypes.wintypes.BOOL 
+ 
+    FILE_ATTRIBUTE_HIDDEN = 0x02 
+ 
+    ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN) 
+    if not ret: 
+        raise ctypes.WinError() 
diff --git a/contrib/python/setuptools/py2/ya.make b/contrib/python/setuptools/py2/ya.make
index 4c36dcf1ab..f096e3524e 100644
--- a/contrib/python/setuptools/py2/ya.make
+++ b/contrib/python/setuptools/py2/ya.make
@@ -1,9 +1,9 @@
 PY2_LIBRARY()
-
+ 
 LICENSE(MIT)
 
 OWNER(g:python-contrib borman orivej)
-
+ 
 VERSION(44.1.1)
 
 PEERDIR(
@@ -16,10 +16,10 @@ NO_CHECK_IMPORTS(
 
 NO_LINT()
 
-PY_SRCS(
-    TOP_LEVEL
+PY_SRCS( 
+    TOP_LEVEL 
     easy_install.py
-    pkg_resources/__init__.py
+    pkg_resources/__init__.py 
     pkg_resources/_vendor/__init__.py
     pkg_resources/_vendor/appdirs.py
     pkg_resources/_vendor/packaging/__about__.py
@@ -35,7 +35,7 @@ PY_SRCS(
     pkg_resources/_vendor/six.py
     pkg_resources/extern/__init__.py
     pkg_resources/py31compat.py
-    setuptools/__init__.py
+    setuptools/__init__.py 
     setuptools/_deprecation_warning.py
     setuptools/_imp.py
     setuptools/_vendor/__init__.py
@@ -52,61 +52,61 @@ PY_SRCS(
     setuptools/_vendor/packaging/version.py
     setuptools/_vendor/pyparsing.py
     setuptools/_vendor/six.py
-    setuptools/archive_util.py
+    setuptools/archive_util.py 
     setuptools/build_meta.py
-    setuptools/command/__init__.py
-    setuptools/command/alias.py
-    setuptools/command/bdist_egg.py
-    setuptools/command/bdist_rpm.py
-    setuptools/command/bdist_wininst.py
+    setuptools/command/__init__.py 
+    setuptools/command/alias.py 
+    setuptools/command/bdist_egg.py 
+    setuptools/command/bdist_rpm.py 
+    setuptools/command/bdist_wininst.py 
     setuptools/command/build_clib.py
-    setuptools/command/build_ext.py
-    setuptools/command/build_py.py
-    setuptools/command/develop.py
+    setuptools/command/build_ext.py 
+    setuptools/command/build_py.py 
+    setuptools/command/develop.py 
     setuptools/command/dist_info.py
-    setuptools/command/easy_install.py
-    setuptools/command/egg_info.py
-    setuptools/command/install.py
-    setuptools/command/install_egg_info.py
-    setuptools/command/install_lib.py
-    setuptools/command/install_scripts.py
+    setuptools/command/easy_install.py 
+    setuptools/command/egg_info.py 
+    setuptools/command/install.py 
+    setuptools/command/install_egg_info.py 
+    setuptools/command/install_lib.py 
+    setuptools/command/install_scripts.py 
     setuptools/command/py36compat.py
-    setuptools/command/register.py
-    setuptools/command/rotate.py
-    setuptools/command/saveopts.py
-    setuptools/command/sdist.py
-    setuptools/command/setopt.py
-    setuptools/command/test.py
+    setuptools/command/register.py 
+    setuptools/command/rotate.py 
+    setuptools/command/saveopts.py 
+    setuptools/command/sdist.py 
+    setuptools/command/setopt.py 
+    setuptools/command/test.py 
     setuptools/command/upload.py
-    setuptools/command/upload_docs.py
+    setuptools/command/upload_docs.py 
     setuptools/config.py
     setuptools/dep_util.py
-    setuptools/depends.py
-    setuptools/dist.py
+    setuptools/depends.py 
+    setuptools/dist.py 
     setuptools/errors.py
-    setuptools/extension.py
+    setuptools/extension.py 
     setuptools/extern/__init__.py
     setuptools/glob.py
     setuptools/installer.py
-    setuptools/launch.py
-    setuptools/lib2to3_ex.py
+    setuptools/launch.py 
+    setuptools/lib2to3_ex.py 
     setuptools/monkey.py
     setuptools/msvc.py
     setuptools/namespaces.py
-    setuptools/package_index.py
-    setuptools/py27compat.py
-    setuptools/py31compat.py
+    setuptools/package_index.py 
+    setuptools/py27compat.py 
+    setuptools/py31compat.py 
     setuptools/py33compat.py
     setuptools/py34compat.py
-    setuptools/sandbox.py
-    setuptools/site-patch.py
-    setuptools/ssl_support.py
-    setuptools/unicode_utils.py
-    setuptools/version.py
+    setuptools/sandbox.py 
+    setuptools/site-patch.py 
+    setuptools/ssl_support.py 
+    setuptools/unicode_utils.py 
+    setuptools/version.py 
     setuptools/wheel.py
-    setuptools/windows_support.py
-)
-
+    setuptools/windows_support.py 
+) 
+ 
 RESOURCE_FILES(
     PREFIX contrib/python/setuptools/py2/
     .dist-info/METADATA
@@ -114,4 +114,4 @@ RESOURCE_FILES(
     .dist-info/top_level.txt
 )
 
-END()
+END()