Commits

holger krekel  committed df22328

drop Python2.5 compatibility because it became too hard due
to the setuptools-2.0 dropping support. tox now has no
support for creating python2.5 virtualenv environments anymore.

  • Participants
  • Parent commits 7744bc2

Comments (0)

Files changed (10)

 1.6.2.dev
 ---------
 
+- drop Python2.5 compatibility because it became too hard due
+  to the setuptools-2.0 dropping support.  tox now has no 
+  support for creating python2.5 virtualenv environments anymore.
+
 - merged PR81: new option --force-dep which allows to 
   override tox.ini specified dependencies in setuptools-style.
   For example "--force-dep 'django<1.6'" will make sure

File tests/test_config.py

         assert envconfig.changedir.basename == "abc"
         assert envconfig.changedir == config.setupdir.join("abc")
 
-    def test_install_command_defaults_py25(self, newconfig, monkeypatch):
-        from tox.interpreters import Interpreters
-        def get_info(self, name):
-            if "x25" in name:
-                class I:
-                    runnable = True
-                    executable = "python2.5"
-                    version_info = (2,5)
-            else:
-                class I:
-                    runnable = False
-                    executable = "python"
-            return I
-        monkeypatch.setattr(Interpreters, "get_info", get_info)
-        config = newconfig("""
-            [testenv:x25]
-            basepython = x25
-            [testenv:py25-x]
-            basepython = x25
-            [testenv:py26]
-            basepython = "python"
-        """)
-        for name in ("x25", "py25-x"):
-            env = config.envconfigs[name]
-            assert env.install_command == \
-               "pip install {opts} {packages}".split()
-        env = config.envconfigs["py26"]
-        assert env.install_command == \
-               "pip install --pre {opts} {packages}".split()
-
     def test_install_command_setting(self, newconfig):
         config = newconfig("""
             [testenv]
 
     def test_simple(tmpdir, newconfig):
         config = newconfig("""
-            [testenv:py24]
-            basepython=python2.4
-            [testenv:py25]
-            basepython=python2.5
+            [testenv:py26]
+            basepython=python2.6
+            [testenv:py27]
+            basepython=python2.7
         """)
         assert len(config.envconfigs) == 2
-        assert "py24" in config.envconfigs
-        assert "py25" in config.envconfigs
+        assert "py26" in config.envconfigs
+        assert "py27" in config.envconfigs
 
     def test_substitution_error(tmpdir, newconfig):
         py.test.raises(tox.exception.ConfigError, newconfig, """

File tests/test_quickstart.py

 
         return mock_term_input
 
-    def test_quickstart_main_choose_individual_pythons_and_pytest(self, monkeypatch):
+    def test_quickstart_main_choose_individual_pythons_and_pytest(self,
+        monkeypatch):
         monkeypatch.setattr(
             tox._quickstart, 'term_input',
-            self.get_mock_term_input(['4', 'Y', 'Y', 'Y', 'Y', 'N', 'N', 'Y', 'Y', 'Y', 'N', 'py.test', 'pytest']))
+            self.get_mock_term_input(
+                ['4', 'Y', 'Y', 'Y', 'Y', 'Y', 'N', 'py.test', 'pytest']))
 
         tox._quickstart.main(argv=['tox-quickstart'])
 
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py32, py33, pypy
+envlist = py26, py27, py32, py33, pypy
 
 [testenv]
 commands = py.test
     def test_quickstart_main_choose_individual_pythons_and_nose_adds_deps(self, monkeypatch):
         monkeypatch.setattr(
             tox._quickstart, 'term_input',
-            self.get_mock_term_input(['4', 'Y', 'Y', 'Y', 'Y', 'N', 'N', 'Y', 'Y', 'Y', 'N', 'nosetests', '']))
+            self.get_mock_term_input(['4', 'Y', 'Y', 'Y', 'Y', 'Y', 'N',
+                                     'nosetests', '']))
 
         tox._quickstart.main(argv=['tox-quickstart'])
 
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py32, py33, pypy
+envlist = py26, py27, py32, py33, pypy
 
 [testenv]
 commands = nosetests
     def test_quickstart_main_choose_individual_pythons_and_trial_adds_deps(self, monkeypatch):
         monkeypatch.setattr(
             tox._quickstart, 'term_input',
-            self.get_mock_term_input(['4', 'Y', 'Y', 'Y', 'Y', 'N', 'N', 'Y', 'Y', 'Y', 'N', 'trial', '']))
+            self.get_mock_term_input(['4', 'Y', 'Y', 'Y', 'Y', 'Y', 'N',
+                                      'trial', '']))
 
         tox._quickstart.main(argv=['tox-quickstart'])
 
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py32, py33, pypy
+envlist = py26, py27, py32, py33, pypy
 
 [testenv]
 commands = trial
     def test_quickstart_main_choose_individual_pythons_and_pytest_adds_deps(self, monkeypatch):
         monkeypatch.setattr(
             tox._quickstart, 'term_input',
-            self.get_mock_term_input(['4', 'Y', 'Y', 'Y', 'Y', 'N', 'N', 'Y', 'Y', 'Y', 'N', 'py.test', '']))
-
+            self.get_mock_term_input(['4', 'Y', 'Y', 'Y', 'Y', 'Y', 'N',
+                                      'py.test', '']))
         tox._quickstart.main(argv=['tox-quickstart'])
 
         expected_tox_ini = """
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py32, py33, pypy
+envlist = py26, py27, py32, py33, pypy
 
 [testenv]
 commands = py.test
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py30, py31, py32, py33, pypy, jython
+envlist = py26, py27, py32, py33, pypy, jython
 
 [testenv]
 commands = py.test
     def test_quickstart_main_choose_individual_pythons_and_defaults(self, monkeypatch):
         monkeypatch.setattr(
             tox._quickstart, 'term_input',
-            self.get_mock_term_input(['4', '', '', '', '', '', '', '', '', '', '', '', '']))
+            self.get_mock_term_input(['4', '', '', '', '', '', '', '', '', '', '']))
 
         tox._quickstart.main(argv=['tox-quickstart'])
 
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py30, py31, py32, py33, pypy, jython
+envlist = py26, py27, py32, py33, pypy, jython
 
 [testenv]
 commands = {envpython} setup.py test
 
         monkeypatch.setattr(
             tox._quickstart, 'term_input',
-            self.get_mock_term_input(['4', '', '', '', '', '', '', '', '', '', '', '', '', '']))
+            self.get_mock_term_input(['4', '', '', '', '', '', '', '', '', '', '', '']))
 
         tox._quickstart.main(argv=['tox-quickstart'])
 
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py30, py31, py32, py33, pypy, jython
+envlist = py26, py27, py32, py33, pypy, jython
 
 [testenv]
 commands = {envpython} setup.py test
 class TestToxQuickstart(object):
     def test_pytest(self):
         d = {
-            'py24': True,
-            'py25': True,
             'py26': True,
             'py27': True,
             'py32': True,
 # and then run "tox" from this directory.
 
 [tox]
-envlist = py24, py25, py26, py27, py32, py33, pypy
+envlist = py26, py27, py32, py33, pypy
 
 [testenv]
 commands = py.test
 [tox]
-envlist=py25,py27,py26,py32,py33,pypy
+envlist=py27,py33,py26,py32,pypy
 
 [testenv:X]
 commands=echo {posargs}

File tox/_config.py

         info = self.config.interpreters.get_info(self.basepython)
         if not info.executable:
             raise tox.exception.InterpreterNotFound(self.basepython)
+        if info.version_info < (2,6):
+            raise tox.exception.UnsupportedInterpreter(
+                "python2.5 is not supported anymore, sorry")
         return info.executable
 
 testenvprefix = "testenv:"
             downloadcache = os.environ.get("PIP_DOWNLOAD_CACHE", downloadcache)
             vc.downloadcache = py.path.local(downloadcache)
 
-        # on pip-1.3.1/python 2.5 we can't use "--pre".
-        pip_default_opts = ["{opts}", "{packages}"]
-        info = vc._basepython_info
-        if info.runnable and info.version_info < (2,6):
-            pass
-        else:
-            pip_default_opts.insert(0, "--pre")
+        pip_default_opts = ["--pre", "{opts}", "{packages}"]
         vc.install_command = reader.getargv(
             section,
             "install_command",

File tox/_pytestplugin.py

 def pytest_report_header():
     return "tox comes from: %r" % (tox.__file__)
 
-def pytest_funcarg__newconfig(request, tmpdir):
+@pytest.fixture
+def newconfig(request, tmpdir):
     def newconfig(args, source=None):
         if source is None:
             source = args
             old.chdir()
     return newconfig
 
-def pytest_funcarg__cmd(request):
+@pytest.fixture
+def cmd(request):
     return Cmd(request)
 
 class ReportExpectMock:
     def wait(self):
         pass
 
-def pytest_funcarg__mocksession(request):
+@pytest.fixture
+def mocksession(request):
     from tox._cmdline import Session
     class MockSession(Session):
         def __init__(self):
             return pm
     return MockSession()
 
-def pytest_funcarg__newmocksession(request):
+@pytest.fixture
+def newmocksession(request):
     mocksession = request.getfuncargvalue("mocksession")
     newconfig = request.getfuncargvalue("newconfig")
     def newmocksession(args, source):

File tox/_quickstart.py

     term_input = input
 
 
-all_envs = ['py25', 'py26', 'py27', 'py30', 'py31', 'py32', 'py33', 'pypy', 'jython']
+all_envs = ['py26', 'py27', 'py32', 'py33', 'pypy', 'jython']
 
 PROMPT_PREFIX = '> '
 

File tox/_venv.py

         interpreters = self.envconfig.config.interpreters
         config_interpreter = self.getsupportedinterpreter()
         info = interpreters.get_info(executable=config_interpreter)
-        use_venv191 = use_pip13 = info.version_info < (2,6)
-        if not use_venv191:
-            f, path, _ = py.std.imp.find_module("virtualenv")
-            f.close()
-            venvscript = path.rstrip("co")
-        else:
-            venvscript = py.path.local(tox.__file__).dirpath(
-                            "vendor", "virtualenv.py")
+        f, path, _ = py.std.imp.find_module("virtualenv")
+        f.close()
+        venvscript = path.rstrip("co")
         args = [config_interpreter, str(venvscript)]
         if self.envconfig.distribute:
             args.append("--distribute")
         args.append(self.path.basename)
         self._pcall(args, venv=False, action=action, cwd=basepath)
         self.just_created = True
-        if use_pip13:
-            indexserver = self.envconfig.config.indexserver['default'].url
-            action = self.session.newaction(self, "pip_downgrade")
-            action.setactivity('pip-downgrade', 'pip<1.4')
-            argv = ["easy_install"] + \
-                   self._installopts(indexserver) + ['pip<1.4']
-            self._pcall(argv, cwd=self.envconfig.config.toxinidir,
-                        action=action)
+
 
     def finish(self):
         self._getliveconfig().writeconfig(self.path_config)

File tox/interpreters.py

 
     def get_executable(self, name):
         """ return path object to the executable for the given
-        name (e.g. python2.5, python2.7, python etc.)
+        name (e.g. python2.6, python2.7, python etc.)
         if name is already an existing path, return name.
         If an interpreter cannot be found, return None.
         """

File tox/vendor/virtualenv.py

-#!/usr/bin/env python
-"""Create a "virtual" Python installation
-"""
-
-# If you change the version here, change it in setup.py
-# and docs/conf.py as well.
-__version__ = "1.9.1"  # following best practices
-virtualenv_version = __version__  # legacy, again
-
-import base64
-import sys
-import os
-import codecs
-import optparse
-import re
-import shutil
-import logging
-import tempfile
-import zlib
-import errno
-import glob
-import distutils.sysconfig
-from distutils.util import strtobool
-import struct
-import subprocess
-
-if sys.version_info < (2, 5):
-    print('ERROR: %s' % sys.exc_info()[1])
-    print('ERROR: this script requires Python 2.5 or greater.')
-    sys.exit(101)
-
-try:
-    set
-except NameError:
-    from sets import Set as set
-try:
-    basestring
-except NameError:
-    basestring = str
-
-try:
-    import ConfigParser
-except ImportError:
-    import configparser as ConfigParser
-
-join = os.path.join
-py_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])
-
-is_jython = sys.platform.startswith('java')
-is_pypy = hasattr(sys, 'pypy_version_info')
-is_win = (sys.platform == 'win32')
-is_cygwin = (sys.platform == 'cygwin')
-is_darwin = (sys.platform == 'darwin')
-abiflags = getattr(sys, 'abiflags', '')
-
-user_dir = os.path.expanduser('~')
-if is_win:
-    default_storage_dir = os.path.join(user_dir, 'virtualenv')
-else:
-    default_storage_dir = os.path.join(user_dir, '.virtualenv')
-default_config_file = os.path.join(default_storage_dir, 'virtualenv.ini')
-
-if is_pypy:
-    expected_exe = 'pypy'
-elif is_jython:
-    expected_exe = 'jython'
-else:
-    expected_exe = 'python'
-
-
-REQUIRED_MODULES = ['os', 'posix', 'posixpath', 'nt', 'ntpath', 'genericpath',
-                    'fnmatch', 'locale', 'encodings', 'codecs',
-                    'stat', 'UserDict', 'readline', 'copy_reg', 'types',
-                    're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',
-                    'zlib']
-
-REQUIRED_FILES = ['lib-dynload', 'config']
-
-majver, minver = sys.version_info[:2]
-if majver == 2:
-    if minver >= 6:
-        REQUIRED_MODULES.extend(['warnings', 'linecache', '_abcoll', 'abc'])
-    if minver >= 7:
-        REQUIRED_MODULES.extend(['_weakrefset'])
-    if minver <= 3:
-        REQUIRED_MODULES.extend(['sets', '__future__'])
-elif majver == 3:
-    # Some extra modules are needed for Python 3, but different ones
-    # for different versions.
-    REQUIRED_MODULES.extend(['_abcoll', 'warnings', 'linecache', 'abc', 'io',
-                             '_weakrefset', 'copyreg', 'tempfile', 'random',
-                             '__future__', 'collections', 'keyword', 'tarfile',
-                             'shutil', 'struct', 'copy', 'tokenize', 'token',
-                             'functools', 'heapq', 'bisect', 'weakref',
-                             'reprlib'])
-    if minver >= 2:
-        REQUIRED_FILES[-1] = 'config-%s' % majver
-    if minver == 3:
-        import sysconfig
-        platdir = sysconfig.get_config_var('PLATDIR')
-        REQUIRED_FILES.append(platdir)
-        # The whole list of 3.3 modules is reproduced below - the current
-        # uncommented ones are required for 3.3 as of now, but more may be
-        # added as 3.3 development continues.
-        REQUIRED_MODULES.extend([
-            #"aifc",
-            #"antigravity",
-            #"argparse",
-            #"ast",
-            #"asynchat",
-            #"asyncore",
-            "base64",
-            #"bdb",
-            #"binhex",
-            #"bisect",
-            #"calendar",
-            #"cgi",
-            #"cgitb",
-            #"chunk",
-            #"cmd",
-            #"codeop",
-            #"code",
-            #"colorsys",
-            #"_compat_pickle",
-            #"compileall",
-            #"concurrent",
-            #"configparser",
-            #"contextlib",
-            #"cProfile",
-            #"crypt",
-            #"csv",
-            #"ctypes",
-            #"curses",
-            #"datetime",
-            #"dbm",
-            #"decimal",
-            #"difflib",
-            #"dis",
-            #"doctest",
-            #"dummy_threading",
-            "_dummy_thread",
-            #"email",
-            #"filecmp",
-            #"fileinput",
-            #"formatter",
-            #"fractions",
-            #"ftplib",
-            #"functools",
-            #"getopt",
-            #"getpass",
-            #"gettext",
-            #"glob",
-            #"gzip",
-            "hashlib",
-            #"heapq",
-            "hmac",
-            #"html",
-            #"http",
-            #"idlelib",
-            #"imaplib",
-            #"imghdr",
-            "imp",
-            "importlib",
-            #"inspect",
-            #"json",
-            #"lib2to3",
-            #"logging",
-            #"macpath",
-            #"macurl2path",
-            #"mailbox",
-            #"mailcap",
-            #"_markupbase",
-            #"mimetypes",
-            #"modulefinder",
-            #"multiprocessing",
-            #"netrc",
-            #"nntplib",
-            #"nturl2path",
-            #"numbers",
-            #"opcode",
-            #"optparse",
-            #"os2emxpath",
-            #"pdb",
-            #"pickle",
-            #"pickletools",
-            #"pipes",
-            #"pkgutil",
-            #"platform",
-            #"plat-linux2",
-            #"plistlib",
-            #"poplib",
-            #"pprint",
-            #"profile",
-            #"pstats",
-            #"pty",
-            #"pyclbr",
-            #"py_compile",
-            #"pydoc_data",
-            #"pydoc",
-            #"_pyio",
-            #"queue",
-            #"quopri",
-            #"reprlib",
-            "rlcompleter",
-            #"runpy",
-            #"sched",
-            #"shelve",
-            #"shlex",
-            #"smtpd",
-            #"smtplib",
-            #"sndhdr",
-            #"socket",
-            #"socketserver",
-            #"sqlite3",
-            #"ssl",
-            #"stringprep",
-            #"string",
-            #"_strptime",
-            #"subprocess",
-            #"sunau",
-            #"symbol",
-            #"symtable",
-            #"sysconfig",
-            #"tabnanny",
-            #"telnetlib",
-            #"test",
-            #"textwrap",
-            #"this",
-            #"_threading_local",
-            #"threading",
-            #"timeit",
-            #"tkinter",
-            #"tokenize",
-            #"token",
-            #"traceback",
-            #"trace",
-            #"tty",
-            #"turtledemo",
-            #"turtle",
-            #"unittest",
-            #"urllib",
-            #"uuid",
-            #"uu",
-            #"wave",
-            #"weakref",
-            #"webbrowser",
-            #"wsgiref",
-            #"xdrlib",
-            #"xml",
-            #"xmlrpc",
-            #"zipfile",
-        ])
-
-if is_pypy:
-    # these are needed to correctly display the exceptions that may happen
-    # during the bootstrap
-    REQUIRED_MODULES.extend(['traceback', 'linecache'])
-
-class Logger(object):
-
-    """
-    Logging object for use in command-line script.  Allows ranges of
-    levels, to avoid some redundancy of displayed information.
-    """
-
-    DEBUG = logging.DEBUG
-    INFO = logging.INFO
-    NOTIFY = (logging.INFO+logging.WARN)/2
-    WARN = WARNING = logging.WARN
-    ERROR = logging.ERROR
-    FATAL = logging.FATAL
-
-    LEVELS = [DEBUG, INFO, NOTIFY, WARN, ERROR, FATAL]
-
-    def __init__(self, consumers):
-        self.consumers = consumers
-        self.indent = 0
-        self.in_progress = None
-        self.in_progress_hanging = False
-
-    def debug(self, msg, *args, **kw):
-        self.log(self.DEBUG, msg, *args, **kw)
-    def info(self, msg, *args, **kw):
-        self.log(self.INFO, msg, *args, **kw)
-    def notify(self, msg, *args, **kw):
-        self.log(self.NOTIFY, msg, *args, **kw)
-    def warn(self, msg, *args, **kw):
-        self.log(self.WARN, msg, *args, **kw)
-    def error(self, msg, *args, **kw):
-        self.log(self.ERROR, msg, *args, **kw)
-    def fatal(self, msg, *args, **kw):
-        self.log(self.FATAL, msg, *args, **kw)
-    def log(self, level, msg, *args, **kw):
-        if args:
-            if kw:
-                raise TypeError(
-                    "You may give positional or keyword arguments, not both")
-        args = args or kw
-        rendered = None
-        for consumer_level, consumer in self.consumers:
-            if self.level_matches(level, consumer_level):
-                if (self.in_progress_hanging
-                    and consumer in (sys.stdout, sys.stderr)):
-                    self.in_progress_hanging = False
-                    sys.stdout.write('\n')
-                    sys.stdout.flush()
-                if rendered is None:
-                    if args:
-                        rendered = msg % args
-                    else:
-                        rendered = msg
-                    rendered = ' '*self.indent + rendered
-                if hasattr(consumer, 'write'):
-                    consumer.write(rendered+'\n')
-                else:
-                    consumer(rendered)
-
-    def start_progress(self, msg):
-        assert not self.in_progress, (
-            "Tried to start_progress(%r) while in_progress %r"
-            % (msg, self.in_progress))
-        if self.level_matches(self.NOTIFY, self._stdout_level()):
-            sys.stdout.write(msg)
-            sys.stdout.flush()
-            self.in_progress_hanging = True
-        else:
-            self.in_progress_hanging = False
-        self.in_progress = msg
-
-    def end_progress(self, msg='done.'):
-        assert self.in_progress, (
-            "Tried to end_progress without start_progress")
-        if self.stdout_level_matches(self.NOTIFY):
-            if not self.in_progress_hanging:
-                # Some message has been printed out since start_progress
-                sys.stdout.write('...' + self.in_progress + msg + '\n')
-                sys.stdout.flush()
-            else:
-                sys.stdout.write(msg + '\n')
-                sys.stdout.flush()
-        self.in_progress = None
-        self.in_progress_hanging = False
-
-    def show_progress(self):
-        """If we are in a progress scope, and no log messages have been
-        shown, write out another '.'"""
-        if self.in_progress_hanging:
-            sys.stdout.write('.')
-            sys.stdout.flush()
-
-    def stdout_level_matches(self, level):
-        """Returns true if a message at this level will go to stdout"""
-        return self.level_matches(level, self._stdout_level())
-
-    def _stdout_level(self):
-        """Returns the level that stdout runs at"""
-        for level, consumer in self.consumers:
-            if consumer is sys.stdout:
-                return level
-        return self.FATAL
-
-    def level_matches(self, level, consumer_level):
-        """
-        >>> l = Logger([])
-        >>> l.level_matches(3, 4)
-        False
-        >>> l.level_matches(3, 2)
-        True
-        >>> l.level_matches(slice(None, 3), 3)
-        False
-        >>> l.level_matches(slice(None, 3), 2)
-        True
-        >>> l.level_matches(slice(1, 3), 1)
-        True
-        >>> l.level_matches(slice(2, 3), 1)
-        False
-        """
-        if isinstance(level, slice):
-            start, stop = level.start, level.stop
-            if start is not None and start > consumer_level:
-                return False
-            if stop is not None and stop <= consumer_level:
-                return False
-            return True
-        else:
-            return level >= consumer_level
-
-    #@classmethod
-    def level_for_integer(cls, level):
-        levels = cls.LEVELS
-        if level < 0:
-            return levels[0]
-        if level >= len(levels):
-            return levels[-1]
-        return levels[level]
-
-    level_for_integer = classmethod(level_for_integer)
-
-# create a silent logger just to prevent this from being undefined
-# will be overridden with requested verbosity main() is called.
-logger = Logger([(Logger.LEVELS[-1], sys.stdout)])
-
-def mkdir(path):
-    if not os.path.exists(path):
-        logger.info('Creating %s', path)
-        os.makedirs(path)
-    else:
-        logger.info('Directory %s already exists', path)
-
-def copyfileordir(src, dest):
-    if os.path.isdir(src):
-        shutil.copytree(src, dest, True)
-    else:
-        shutil.copy2(src, dest)
-
-def copyfile(src, dest, symlink=True):
-    if not os.path.exists(src):
-        # Some bad symlink in the src
-        logger.warn('Cannot find file %s (bad symlink)', src)
-        return
-    if os.path.exists(dest):
-        logger.debug('File %s already exists', dest)
-        return
-    if not os.path.exists(os.path.dirname(dest)):
-        logger.info('Creating parent directories for %s' % os.path.dirname(dest))
-        os.makedirs(os.path.dirname(dest))
-    if not os.path.islink(src):
-        srcpath = os.path.abspath(src)
-    else:
-        srcpath = os.readlink(src)
-    if symlink and hasattr(os, 'symlink') and not is_win:
-        logger.info('Symlinking %s', dest)
-        try:
-            os.symlink(srcpath, dest)
-        except (OSError, NotImplementedError):
-            logger.info('Symlinking failed, copying to %s', dest)
-            copyfileordir(src, dest)
-    else:
-        logger.info('Copying to %s', dest)
-        copyfileordir(src, dest)
-
-def writefile(dest, content, overwrite=True):
-    if not os.path.exists(dest):
-        logger.info('Writing %s', dest)
-        f = open(dest, 'wb')
-        f.write(content.encode('utf-8'))
-        f.close()
-        return
-    else:
-        f = open(dest, 'rb')
-        c = f.read()
-        f.close()
-        if c != content.encode("utf-8"):
-            if not overwrite:
-                logger.notify('File %s exists with different content; not overwriting', dest)
-                return
-            logger.notify('Overwriting %s with new content', dest)
-            f = open(dest, 'wb')
-            f.write(content.encode('utf-8'))
-            f.close()
-        else:
-            logger.info('Content %s already in place', dest)
-
-def rmtree(dir):
-    if os.path.exists(dir):
-        logger.notify('Deleting tree %s', dir)
-        shutil.rmtree(dir)
-    else:
-        logger.info('Do not need to delete %s; already gone', dir)
-
-def make_exe(fn):
-    if hasattr(os, 'chmod'):
-        oldmode = os.stat(fn).st_mode & 0xFFF # 0o7777
-        newmode = (oldmode | 0x16D) & 0xFFF # 0o555, 0o7777
-        os.chmod(fn, newmode)
-        logger.info('Changed mode of %s to %s', fn, oct(newmode))
-
-def _find_file(filename, dirs):
-    for dir in reversed(dirs):
-        files = glob.glob(os.path.join(dir, filename))
-        if files and os.path.isfile(files[0]):
-            return True, files[0]
-    return False, filename
-
-def _install_req(py_executable, unzip=False, distribute=False,
-                 search_dirs=None, never_download=False):
-
-    if search_dirs is None:
-        search_dirs = file_search_dirs()
-
-    if not distribute:
-        egg_path = 'setuptools-*-py%s.egg' % sys.version[:3]
-        found, egg_path = _find_file(egg_path, search_dirs)
-        project_name = 'setuptools'
-        bootstrap_script = EZ_SETUP_PY
-        tgz_path = None
-    else:
-        # Look for a distribute egg (these are not distributed by default,
-        # but can be made available by the user)
-        egg_path = 'distribute-*-py%s.egg' % sys.version[:3]
-        found, egg_path = _find_file(egg_path, search_dirs)
-        project_name = 'distribute'
-        if found:
-            tgz_path = None
-            bootstrap_script = DISTRIBUTE_FROM_EGG_PY
-        else:
-            # Fall back to sdist
-            # NB: egg_path is not None iff tgz_path is None
-            # iff bootstrap_script is a generic setup script accepting
-            # the standard arguments.
-            egg_path = None
-            tgz_path = 'distribute-*.tar.gz'
-            found, tgz_path = _find_file(tgz_path, search_dirs)
-            bootstrap_script = DISTRIBUTE_SETUP_PY
-
-    if is_jython and os._name == 'nt':
-        # Jython's .bat sys.executable can't handle a command line
-        # argument with newlines
-        fd, ez_setup = tempfile.mkstemp('.py')
-        os.write(fd, bootstrap_script)
-        os.close(fd)
-        cmd = [py_executable, ez_setup]
-    else:
-        cmd = [py_executable, '-c', bootstrap_script]
-    if unzip and egg_path:
-        cmd.append('--always-unzip')
-    env = {}
-    remove_from_env = ['__PYVENV_LAUNCHER__']
-    if logger.stdout_level_matches(logger.DEBUG) and egg_path:
-        cmd.append('-v')
-
-    old_chdir = os.getcwd()
-    if egg_path is not None and os.path.exists(egg_path):
-        logger.info('Using existing %s egg: %s' % (project_name, egg_path))
-        cmd.append(egg_path)
-        if os.environ.get('PYTHONPATH'):
-            env['PYTHONPATH'] = egg_path + os.path.pathsep + os.environ['PYTHONPATH']
-        else:
-            env['PYTHONPATH'] = egg_path
-    elif tgz_path is not None and os.path.exists(tgz_path):
-        # Found a tgz source dist, let's chdir
-        logger.info('Using existing %s egg: %s' % (project_name, tgz_path))
-        os.chdir(os.path.dirname(tgz_path))
-        # in this case, we want to be sure that PYTHONPATH is unset (not
-        # just empty, really unset), else CPython tries to import the
-        # site.py that it's in virtualenv_support
-        remove_from_env.append('PYTHONPATH')
-    elif never_download:
-        logger.fatal("Can't find any local distributions of %s to install "
-                     "and --never-download is set.  Either re-run virtualenv "
-                     "without the --never-download option, or place a %s "
-                     "distribution (%s) in one of these "
-                     "locations: %r" % (project_name, project_name,
-                                        egg_path or tgz_path,
-                                        search_dirs))
-        sys.exit(1)
-    elif egg_path:
-        logger.info('No %s egg found; downloading' % project_name)
-        cmd.extend(['--always-copy', '-U', project_name])
-    else:
-        logger.info('No %s tgz found; downloading' % project_name)
-    logger.start_progress('Installing %s...' % project_name)
-    logger.indent += 2
-    cwd = None
-    if project_name == 'distribute':
-        env['DONT_PATCH_SETUPTOOLS'] = 'true'
-
-    def _filter_ez_setup(line):
-        return filter_ez_setup(line, project_name)
-
-    if not os.access(os.getcwd(), os.W_OK):
-        cwd = tempfile.mkdtemp()
-        if tgz_path is not None and os.path.exists(tgz_path):
-            # the current working dir is hostile, let's copy the
-            # tarball to a temp dir
-            target = os.path.join(cwd, os.path.split(tgz_path)[-1])
-            shutil.copy(tgz_path, target)
-    try:
-        call_subprocess(cmd, show_stdout=False,
-                        filter_stdout=_filter_ez_setup,
-                        extra_env=env,
-                        remove_from_env=remove_from_env,
-                        cwd=cwd)
-    finally:
-        logger.indent -= 2
-        logger.end_progress()
-        if cwd is not None:
-            shutil.rmtree(cwd)
-        if os.getcwd() != old_chdir:
-            os.chdir(old_chdir)
-        if is_jython and os._name == 'nt':
-            os.remove(ez_setup)
-
-def file_search_dirs():
-    here = os.path.dirname(os.path.abspath(__file__))
-    dirs = ['.', here,
-            join(here, 'virtualenv_support')]
-    if os.path.splitext(os.path.dirname(__file__))[0] != 'virtualenv':
-        # Probably some boot script; just in case virtualenv is installed...
-        try:
-            import virtualenv
-        except ImportError:
-            pass
-        else:
-            dirs.append(os.path.join(os.path.dirname(virtualenv.__file__), 'virtualenv_support'))
-    return [d for d in dirs if os.path.isdir(d)]
-
-def install_setuptools(py_executable, unzip=False,
-                       search_dirs=None, never_download=False):
-    _install_req(py_executable, unzip,
-                 search_dirs=search_dirs, never_download=never_download)
-
-def install_distribute(py_executable, unzip=False,
-                       search_dirs=None, never_download=False):
-    _install_req(py_executable, unzip, distribute=True,
-                 search_dirs=search_dirs, never_download=never_download)
-
-_pip_re = re.compile(r'^pip-.*(zip|tar.gz|tar.bz2|tgz|tbz)$', re.I)
-def install_pip(py_executable, search_dirs=None, never_download=False):
-    if search_dirs is None:
-        search_dirs = file_search_dirs()
-
-    filenames = []
-    for dir in search_dirs:
-        filenames.extend([join(dir, fn) for fn in os.listdir(dir)
-                          if _pip_re.search(fn)])
-    filenames = [(os.path.basename(filename).lower(), i, filename) for i, filename in enumerate(filenames)]
-    filenames.sort()
-    filenames = [filename for basename, i, filename in filenames]
-    if not filenames:
-        filename = 'pip'
-    else:
-        filename = filenames[-1]
-    easy_install_script = 'easy_install'
-    if is_win:
-        easy_install_script = 'easy_install-script.py'
-    # There's two subtle issues here when invoking easy_install.
-    # 1. On unix-like systems the easy_install script can *only* be executed
-    #    directly if its full filesystem path is no longer than 78 characters.
-    # 2. A work around to [1] is to use the `python path/to/easy_install foo`
-    #    pattern, but that breaks if the path contains non-ASCII characters, as
-    #    you can't put the file encoding declaration before the shebang line.
-    # The solution is to use Python's -x flag to skip the first line of the
-    # script (and any ASCII decoding errors that may have occurred in that line)
-    cmd = [py_executable, '-x', join(os.path.dirname(py_executable), easy_install_script), filename]
-    # jython and pypy don't yet support -x
-    if is_jython or is_pypy:
-        cmd.remove('-x')
-    if filename == 'pip':
-        if never_download:
-            logger.fatal("Can't find any local distributions of pip to install "
-                         "and --never-download is set.  Either re-run virtualenv "
-                         "without the --never-download option, or place a pip "
-                         "source distribution (zip/tar.gz/tar.bz2) in one of these "
-                         "locations: %r" % search_dirs)
-            sys.exit(1)
-        logger.info('Installing pip from network...')
-    else:
-        logger.info('Installing existing %s distribution: %s' % (
-                os.path.basename(filename), filename))
-    logger.start_progress('Installing pip...')
-    logger.indent += 2
-    def _filter_setup(line):
-        return filter_ez_setup(line, 'pip')
-    try:
-        call_subprocess(cmd, show_stdout=False,
-                        filter_stdout=_filter_setup)
-    finally:
-        logger.indent -= 2
-        logger.end_progress()
-
-def filter_ez_setup(line, project_name='setuptools'):
-    if not line.strip():
-        return Logger.DEBUG
-    if project_name == 'distribute':
-        for prefix in ('Extracting', 'Now working', 'Installing', 'Before',
-                       'Scanning', 'Setuptools', 'Egg', 'Already',
-                       'running', 'writing', 'reading', 'installing',
-                       'creating', 'copying', 'byte-compiling', 'removing',
-                       'Processing'):
-            if line.startswith(prefix):
-                return Logger.DEBUG
-        return Logger.DEBUG
-    for prefix in ['Reading ', 'Best match', 'Processing setuptools',
-                   'Copying setuptools', 'Adding setuptools',
-                   'Installing ', 'Installed ']:
-        if line.startswith(prefix):
-            return Logger.DEBUG
-    return Logger.INFO
-
-
-class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):
-    """
-    Custom help formatter for use in ConfigOptionParser that updates
-    the defaults before expanding them, allowing them to show up correctly
-    in the help listing
-    """
-    def expand_default(self, option):
-        if self.parser is not None:
-            self.parser.update_defaults(self.parser.defaults)
-        return optparse.IndentedHelpFormatter.expand_default(self, option)
-
-
-class ConfigOptionParser(optparse.OptionParser):
-    """
-    Custom option parser which updates its defaults by by checking the
-    configuration files and environmental variables
-    """
-    def __init__(self, *args, **kwargs):
-        self.config = ConfigParser.RawConfigParser()
-        self.files = self.get_config_files()
-        self.config.read(self.files)
-        optparse.OptionParser.__init__(self, *args, **kwargs)
-
-    def get_config_files(self):
-        config_file = os.environ.get('VIRTUALENV_CONFIG_FILE', False)
-        if config_file and os.path.exists(config_file):
-            return [config_file]
-        return [default_config_file]
-
-    def update_defaults(self, defaults):
-        """
-        Updates the given defaults with values from the config files and
-        the environ. Does a little special handling for certain types of
-        options (lists).
-        """
-        # Then go and look for the other sources of configuration:
-        config = {}
-        # 1. config files
-        config.update(dict(self.get_config_section('virtualenv')))
-        # 2. environmental variables
-        config.update(dict(self.get_environ_vars()))
-        # Then set the options with those values
-        for key, val in config.items():
-            key = key.replace('_', '-')
-            if not key.startswith('--'):
-                key = '--%s' % key  # only prefer long opts
-            option = self.get_option(key)
-            if option is not None:
-                # ignore empty values
-                if not val:
-                    continue
-                # handle multiline configs
-                if option.action == 'append':
-                    val = val.split()
-                else:
-                    option.nargs = 1
-                if option.action == 'store_false':
-                    val = not strtobool(val)
-                elif option.action in ('store_true', 'count'):
-                    val = strtobool(val)
-                try:
-                    val = option.convert_value(key, val)
-                except optparse.OptionValueError:
-                    e = sys.exc_info()[1]
-                    print("An error occured during configuration: %s" % e)
-                    sys.exit(3)
-                defaults[option.dest] = val
-        return defaults
-
-    def get_config_section(self, name):
-        """
-        Get a section of a configuration
-        """
-        if self.config.has_section(name):
-            return self.config.items(name)
-        return []
-
-    def get_environ_vars(self, prefix='VIRTUALENV_'):
-        """
-        Returns a generator with all environmental vars with prefix VIRTUALENV
-        """
-        for key, val in os.environ.items():
-            if key.startswith(prefix):
-                yield (key.replace(prefix, '').lower(), val)
-
-    def get_default_values(self):
-        """
-        Overridding to make updating the defaults after instantiation of
-        the option parser possible, update_defaults() does the dirty work.
-        """
-        if not self.process_default_values:
-            # Old, pre-Optik 1.5 behaviour.
-            return optparse.Values(self.defaults)
-
-        defaults = self.update_defaults(self.defaults.copy())  # ours
-        for option in self._get_all_options():
-            default = defaults.get(option.dest)
-            if isinstance(default, basestring):
-                opt_str = option.get_opt_string()
-                defaults[option.dest] = option.check_value(opt_str, default)
-        return optparse.Values(defaults)
-
-
-def main():
-    parser = ConfigOptionParser(
-        version=virtualenv_version,
-        usage="%prog [OPTIONS] DEST_DIR",
-        formatter=UpdatingDefaultsHelpFormatter())
-
-    parser.add_option(
-        '-v', '--verbose',
-        action='count',
-        dest='verbose',
-        default=0,
-        help="Increase verbosity")
-
-    parser.add_option(
-        '-q', '--quiet',
-        action='count',
-        dest='quiet',
-        default=0,
-        help='Decrease verbosity')
-
-    parser.add_option(
-        '-p', '--python',
-        dest='python',
-        metavar='PYTHON_EXE',
-        help='The Python interpreter to use, e.g., --python=python2.5 will use the python2.5 '
-        'interpreter to create the new environment.  The default is the interpreter that '
-        'virtualenv was installed with (%s)' % sys.executable)
-
-    parser.add_option(
-        '--clear',
-        dest='clear',
-        action='store_true',
-        help="Clear out the non-root install and start from scratch")
-
-    parser.set_defaults(system_site_packages=False)
-    parser.add_option(
-        '--no-site-packages',
-        dest='system_site_packages',
-        action='store_false',
-        help="Don't give access to the global site-packages dir to the "
-             "virtual environment (default)")
-
-    parser.add_option(
-        '--system-site-packages',
-        dest='system_site_packages',
-        action='store_true',
-        help="Give access to the global site-packages dir to the "
-             "virtual environment")
-
-    parser.add_option(
-        '--unzip-setuptools',
-        dest='unzip_setuptools',
-        action='store_true',
-        help="Unzip Setuptools or Distribute when installing it")
-
-    parser.add_option(
-        '--relocatable',
-        dest='relocatable',
-        action='store_true',
-        help='Make an EXISTING virtualenv environment relocatable.  '
-        'This fixes up scripts and makes all .pth files relative')
-
-    parser.add_option(
-        '--distribute', '--use-distribute',  # the second option is for legacy reasons here. Hi Kenneth!
-        dest='use_distribute',
-        action='store_true',
-        help='Use Distribute instead of Setuptools. Set environ variable '
-        'VIRTUALENV_DISTRIBUTE to make it the default ')
-
-    parser.add_option(
-        '--no-setuptools',
-        dest='no_setuptools',
-        action='store_true',
-        help='Do not install distribute/setuptools (or pip) '
-        'in the new virtualenv.')
-
-    parser.add_option(
-        '--no-pip',
-        dest='no_pip',
-        action='store_true',
-        help='Do not install pip in the new virtualenv.')
-
-    parser.add_option(
-        '--setuptools',
-        dest='use_distribute',
-        action='store_false',
-        help='Use Setuptools instead of Distribute.  Set environ variable '
-        'VIRTUALENV_SETUPTOOLS to make it the default ')
-
-    # Set this to True to use distribute by default, even in Python 2.
-    parser.set_defaults(use_distribute=False)
-
-    default_search_dirs = file_search_dirs()
-    parser.add_option(
-        '--extra-search-dir',
-        dest="search_dirs",
-        action="append",
-        default=default_search_dirs,
-        help="Directory to look for setuptools/distribute/pip distributions in. "
-        "You can add any number of additional --extra-search-dir paths.")
-
-    parser.add_option(
-        '--never-download',
-        dest="never_download",
-        action="store_true",
-        help="Never download anything from the network.  Instead, virtualenv will fail "
-        "if local distributions of setuptools/distribute/pip are not present.")
-
-    parser.add_option(
-        '--prompt',
-        dest='prompt',
-        help='Provides an alternative prompt prefix for this environment')
-
-    if 'extend_parser' in globals():
-        extend_parser(parser)
-
-    options, args = parser.parse_args()
-
-    global logger
-
-    if 'adjust_options' in globals():
-        adjust_options(options, args)
-
-    verbosity = options.verbose - options.quiet
-    logger = Logger([(Logger.level_for_integer(2 - verbosity), sys.stdout)])
-
-    if options.python and not os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'):
-        env = os.environ.copy()
-        interpreter = resolve_interpreter(options.python)
-        if interpreter == sys.executable:
-            logger.warn('Already using interpreter %s' % interpreter)
-        else:
-            logger.notify('Running virtualenv with interpreter %s' % interpreter)
-            env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'
-            file = __file__
-            if file.endswith('.pyc'):
-                file = file[:-1]
-            popen = subprocess.Popen([interpreter, file] + sys.argv[1:], env=env)
-            raise SystemExit(popen.wait())
-
-    # Force --distribute on Python 3, since setuptools is not available.
-    if majver > 2:
-        options.use_distribute = True
-
-    if os.environ.get('PYTHONDONTWRITEBYTECODE') and not options.use_distribute:
-        print(
-            "The PYTHONDONTWRITEBYTECODE environment variable is "
-            "not compatible with setuptools. Either use --distribute "
-            "or unset PYTHONDONTWRITEBYTECODE.")
-        sys.exit(2)
-    if not args:
-        print('You must provide a DEST_DIR')
-        parser.print_help()
-        sys.exit(2)
-    if len(args) > 1:
-        print('There must be only one argument: DEST_DIR (you gave %s)' % (
-            ' '.join(args)))
-        parser.print_help()
-        sys.exit(2)
-
-    home_dir = args[0]
-
-    if os.environ.get('WORKING_ENV'):
-        logger.fatal('ERROR: you cannot run virtualenv while in a workingenv')
-        logger.fatal('Please deactivate your workingenv, then re-run this script')
-        sys.exit(3)
-
-    if 'PYTHONHOME' in os.environ:
-        logger.warn('PYTHONHOME is set.  You *must* activate the virtualenv before using it')
-        del os.environ['PYTHONHOME']
-
-    if options.relocatable:
-        make_environment_relocatable(home_dir)
-        return
-
-    create_environment(home_dir,
-                       site_packages=options.system_site_packages,
-                       clear=options.clear,
-                       unzip_setuptools=options.unzip_setuptools,
-                       use_distribute=options.use_distribute,
-                       prompt=options.prompt,
-                       search_dirs=options.search_dirs,
-                       never_download=options.never_download,
-                       no_setuptools=options.no_setuptools,
-                       no_pip=options.no_pip)
-    if 'after_install' in globals():
-        after_install(options, home_dir)
-
-def call_subprocess(cmd, show_stdout=True,
-                    filter_stdout=None, cwd=None,
-                    raise_on_returncode=True, extra_env=None,
-                    remove_from_env=None):
-    cmd_parts = []
-    for part in cmd:
-        if len(part) > 45:
-            part = part[:20]+"..."+part[-20:]
-        if ' ' in part or '\n' in part or '"' in part or "'" in part:
-            part = '"%s"' % part.replace('"', '\\"')
-        if hasattr(part, 'decode'):
-            try:
-                part = part.decode(sys.getdefaultencoding())
-            except UnicodeDecodeError:
-                part = part.decode(sys.getfilesystemencoding())
-        cmd_parts.append(part)
-    cmd_desc = ' '.join(cmd_parts)
-    if show_stdout:
-        stdout = None
-    else:
-        stdout = subprocess.PIPE
-    logger.debug("Running command %s" % cmd_desc)
-    if extra_env or remove_from_env:
-        env = os.environ.copy()
-        if extra_env:
-            env.update(extra_env)
-        if remove_from_env:
-            for varname in remove_from_env:
-                env.pop(varname, None)
-    else:
-        env = None
-    try:
-        proc = subprocess.Popen(
-            cmd, stderr=subprocess.STDOUT, stdin=None, stdout=stdout,
-            cwd=cwd, env=env)
-    except Exception:
-        e = sys.exc_info()[1]
-        logger.fatal(
-            "Error %s while executing command %s" % (e, cmd_desc))
-        raise
-    all_output = []
-    if stdout is not None:
-        stdout = proc.stdout
-        encoding = sys.getdefaultencoding()
-        fs_encoding = sys.getfilesystemencoding()
-        while 1:
-            line = stdout.readline()
-            try:
-                line = line.decode(encoding)
-            except UnicodeDecodeError:
-                line = line.decode(fs_encoding)
-            if not line:
-                break
-            line = line.rstrip()
-            all_output.append(line)
-            if filter_stdout:
-                level = filter_stdout(line)
-                if isinstance(level, tuple):
-                    level, line = level
-                logger.log(level, line)
-                if not logger.stdout_level_matches(level):
-                    logger.show_progress()
-            else:
-                logger.info(line)
-    else:
-        proc.communicate()
-    proc.wait()
-    if proc.returncode:
-        if raise_on_returncode:
-            if all_output:
-                logger.notify('Complete output from command %s:' % cmd_desc)
-                logger.notify('\n'.join(all_output) + '\n----------------------------------------')
-            raise OSError(
-                "Command %s failed with error code %s"
-                % (cmd_desc, proc.returncode))
-        else:
-            logger.warn(
-                "Command %s had error code %s"
-                % (cmd_desc, proc.returncode))
-
-
-def create_environment(home_dir, site_packages=False, clear=False,
-                       unzip_setuptools=False, use_distribute=False,
-                       prompt=None, search_dirs=None, never_download=False,
-                       no_setuptools=False, no_pip=False):
-    """
-    Creates a new environment in ``home_dir``.
-
-    If ``site_packages`` is true, then the global ``site-packages/``
-    directory will be on the path.
-
-    If ``clear`` is true (default False) then the environment will
-    first be cleared.
-    """
-    home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir)
-
-    py_executable = os.path.abspath(install_python(
-        home_dir, lib_dir, inc_dir, bin_dir,
-        site_packages=site_packages, clear=clear))
-
-    install_distutils(home_dir)
-
-    if not no_setuptools:
-        if use_distribute:
-            install_distribute(py_executable, unzip=unzip_setuptools,
-                               search_dirs=search_dirs, never_download=never_download)
-        else:
-            install_setuptools(py_executable, unzip=unzip_setuptools,
-                               search_dirs=search_dirs, never_download=never_download)
-
-        if not no_pip:
-            install_pip(py_executable, search_dirs=search_dirs, never_download=never_download)
-
-    install_activate(home_dir, bin_dir, prompt)
-
-def is_executable_file(fpath):
-    return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
-
-def path_locations(home_dir):
-    """Return the path locations for the environment (where libraries are,
-    where scripts go, etc)"""
-    # XXX: We'd use distutils.sysconfig.get_python_inc/lib but its
-    # prefix arg is broken: http://bugs.python.org/issue3386
-    if is_win:
-        # Windows has lots of problems with executables with spaces in
-        # the name; this function will remove them (using the ~1
-        # format):
-        mkdir(home_dir)
-        if ' ' in home_dir:
-            import ctypes
-            GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW
-            size = max(len(home_dir)+1, 256)
-            buf = ctypes.create_unicode_buffer(size)
-            try:
-                u = unicode
-            except NameError:
-                u = str
-            ret = GetShortPathName(u(home_dir), buf, size)
-            if not ret:
-                print('Error: the path "%s" has a space in it' % home_dir)
-                print('We could not determine the short pathname for it.')
-                print('Exiting.')
-                sys.exit(3)
-            home_dir = str(buf.value)
-        lib_dir = join(home_dir, 'Lib')
-        inc_dir = join(home_dir, 'Include')
-        bin_dir = join(home_dir, 'Scripts')
-    if is_jython:
-        lib_dir = join(home_dir, 'Lib')
-        inc_dir = join(home_dir, 'Include')
-        bin_dir = join(home_dir, 'bin')
-    elif is_pypy:
-        lib_dir = home_dir
-        inc_dir = join(home_dir, 'include')
-        bin_dir = join(home_dir, 'bin')
-    elif not is_win:
-        lib_dir = join(home_dir, 'lib', py_version)
-        multiarch_exec = '/usr/bin/multiarch-platform'
-        if is_executable_file(multiarch_exec):
-            # In Mageia (2) and Mandriva distros the include dir must be like:
-            # virtualenv/include/multiarch-x86_64-linux/python2.7
-            # instead of being virtualenv/include/python2.7
-            p = subprocess.Popen(multiarch_exec, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            stdout, stderr = p.communicate()
-            # stdout.strip is needed to remove newline character
-            inc_dir = join(home_dir, 'include', stdout.strip(), py_version + abiflags)
-        else:
-            inc_dir = join(home_dir, 'include', py_version + abiflags)
-        bin_dir = join(home_dir, 'bin')
-    return home_dir, lib_dir, inc_dir, bin_dir
-
-
-def change_prefix(filename, dst_prefix):
-    prefixes = [sys.prefix]
-
-    if is_darwin:
-        prefixes.extend((
-            os.path.join("/Library/Python", sys.version[:3], "site-packages"),
-            os.path.join(sys.prefix, "Extras", "lib", "python"),
-            os.path.join("~", "Library", "Python", sys.version[:3], "site-packages"),
-            # Python 2.6 no-frameworks
-            os.path.join("~", ".local", "lib","python", sys.version[:3], "site-packages"),
-            # System Python 2.7 on OSX Mountain Lion
-            os.path.join("~", "Library", "Python", sys.version[:3], "lib", "python", "site-packages")))
-
-    if hasattr(sys, 'real_prefix'):
-        prefixes.append(sys.real_prefix)
-    if hasattr(sys, 'base_prefix'):
-        prefixes.append(sys.base_prefix)
-    prefixes = list(map(os.path.expanduser, prefixes))
-    prefixes = list(map(os.path.abspath, prefixes))
-    # Check longer prefixes first so we don't split in the middle of a filename
-    prefixes = sorted(prefixes, key=len, reverse=True)
-    filename = os.path.abspath(filename)
-    for src_prefix in prefixes:
-        if filename.startswith(src_prefix):
-            _, relpath = filename.split(src_prefix, 1)
-            if src_prefix != os.sep: # sys.prefix == "/"
-                assert relpath[0] == os.sep
-                relpath = relpath[1:]
-            return join(dst_prefix, relpath)
-    assert False, "Filename %s does not start with any of these prefixes: %s" % \
-        (filename, prefixes)
-
-def copy_required_modules(dst_prefix):
-    import imp
-    # If we are running under -p, we need to remove the current
-    # directory from sys.path temporarily here, so that we
-    # definitely get the modules from the site directory of
-    # the interpreter we are running under, not the one
-    # virtualenv.py is installed under (which might lead to py2/py3
-    # incompatibility issues)
-    _prev_sys_path = sys.path
-    if os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'):
-        sys.path = sys.path[1:]
-    try:
-        for modname in REQUIRED_MODULES:
-            if modname in sys.builtin_module_names:
-                logger.info("Ignoring built-in bootstrap module: %s" % modname)
-                continue
-            try:
-                f, filename, _ = imp.find_module(modname)
-            except ImportError:
-                logger.info("Cannot import bootstrap module: %s" % modname)
-            else:
-                if f is not None:
-                    f.close()
-                # special-case custom readline.so on OS X, but not for pypy:
-                if modname == 'readline' and sys.platform == 'darwin' and not (
-                        is_pypy or filename.endswith(join('lib-dynload', 'readline.so'))):
-                    dst_filename = join(dst_prefix, 'lib', 'python%s' % sys.version[:3], 'readline.so')
-                else:
-                    dst_filename = change_prefix(filename, dst_prefix)
-                copyfile(filename, dst_filename)
-                if filename.endswith('.pyc'):
-                    pyfile = filename[:-1]
-                    if os.path.exists(pyfile):
-                        copyfile(pyfile, dst_filename[:-1])
-    finally:
-        sys.path = _prev_sys_path
-
-
-def subst_path(prefix_path, prefix, home_dir):
-    prefix_path = os.path.normpath(prefix_path)
-    prefix = os.path.normpath(prefix)
-    home_dir = os.path.normpath(home_dir)
-    if not prefix_path.startswith(prefix):
-        logger.warn('Path not in prefix %r %r', prefix_path, prefix)
-        return
-    return prefix_path.replace(prefix, home_dir, 1)
-
-
-def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear):
-    """Install just the base environment, no distutils patches etc"""
-    if sys.executable.startswith(bin_dir):
-        print('Please use the *system* python to run this script')
-        return
-
-    if clear:
-        rmtree(lib_dir)
-        ## FIXME: why not delete it?
-        ## Maybe it should delete everything with #!/path/to/venv/python in it
-        logger.notify('Not deleting %s', bin_dir)
-
-    if hasattr(sys, 'real_prefix'):
-        logger.notify('Using real prefix %r' % sys.real_prefix)
-        prefix = sys.real_prefix
-    elif hasattr(sys, 'base_prefix'):
-        logger.notify('Using base prefix %r' % sys.base_prefix)
-        prefix = sys.base_prefix
-    else:
-        prefix = sys.prefix
-    mkdir(lib_dir)
-    fix_lib64(lib_dir)
-    stdlib_dirs = [os.path.dirname(os.__file__)]
-    if is_win:
-        stdlib_dirs.append(join(os.path.dirname(stdlib_dirs[0]), 'DLLs'))
-    elif is_darwin:
-        stdlib_dirs.append(join(stdlib_dirs[0], 'site-packages'))
-    if hasattr(os, 'symlink'):
-        logger.info('Symlinking Python bootstrap modules')
-    else:
-        logger.info('Copying Python bootstrap modules')
-    logger.indent += 2
-    try:
-        # copy required files...
-        for stdlib_dir in stdlib_dirs:
-            if not os.path.isdir(stdlib_dir):
-                continue
-            for fn in os.listdir(stdlib_dir):
-                bn = os.path.splitext(fn)[0]
-                if fn != 'site-packages' and bn in REQUIRED_FILES:
-                    copyfile(join(stdlib_dir, fn), join(lib_dir, fn))
-        # ...and modules
-        copy_required_modules(home_dir)
-    finally:
-        logger.indent -= 2
-    mkdir(join(lib_dir, 'site-packages'))
-    import site
-    site_filename = site.__file__
-    if site_filename.endswith('.pyc'):
-        site_filename = site_filename[:-1]
-    elif site_filename.endswith('$py.class'):
-        site_filename = site_filename.replace('$py.class', '.py')
-    site_filename_dst = change_prefix(site_filename, home_dir)
-    site_dir = os.path.dirname(site_filename_dst)
-    writefile(site_filename_dst, SITE_PY)
-    writefile(join(site_dir, 'orig-prefix.txt'), prefix)
-    site_packages_filename = join(site_dir, 'no-global-site-packages.txt')
-    if not site_packages:
-        writefile(site_packages_filename, '')
-
-    if is_pypy or is_win:
-        stdinc_dir = join(prefix, 'include')
-    else:
-        stdinc_dir = join(prefix, 'include', py_version + abiflags)
-    if os.path.exists(stdinc_dir):
-        copyfile(stdinc_dir, inc_dir)
-    else:
-        logger.debug('No include dir %s' % stdinc_dir)
-
-    platinc_dir = distutils.sysconfig.get_python_inc(plat_specific=1)
-    if platinc_dir != stdinc_dir:
-        platinc_dest = distutils.sysconfig.get_python_inc(
-            plat_specific=1, prefix=home_dir)
-        if platinc_dir == platinc_dest:
-            # Do platinc_dest manually due to a CPython bug;
-            # not http://bugs.python.org/issue3386 but a close cousin
-            platinc_dest = subst_path(platinc_dir, prefix, home_dir)
-        if platinc_dest:
-            # PyPy's stdinc_dir and prefix are relative to the original binary
-            # (traversing virtualenvs), whereas the platinc_dir is relative to
-            # the inner virtualenv and ignores the prefix argument.
-            # This seems more evolved than designed.
-            copyfile(platinc_dir, platinc_dest)
-
-    # pypy never uses exec_prefix, just ignore it
-    if sys.exec_prefix != prefix and not is_pypy:
-        if is_win:
-            exec_dir = join(sys.exec_prefix, 'lib')
-        elif is_jython:
-            exec_dir = join(sys.exec_prefix, 'Lib')
-        else:
-            exec_dir = join(sys.exec_prefix, 'lib', py_version)
-        for fn in os.listdir(exec_dir):
-            copyfile(join(exec_dir, fn), join(lib_dir, fn))
-
-    if is_jython:
-        # Jython has either jython-dev.jar and javalib/ dir, or just
-        # jython.jar
-        for name in 'jython-dev.jar', 'javalib', 'jython.jar':
-            src = join(prefix, name)
-            if os.path.exists(src):
-                copyfile(src, join(home_dir, name))
-        # XXX: registry should always exist after Jython 2.5rc1
-        src = join(prefix, 'registry')
-        if os.path.exists(src):
-            copyfile(src, join(home_dir, 'registry'), symlink=False)
-        copyfile(join(prefix, 'cachedir'), join(home_dir, 'cachedir'),
-                 symlink=False)
-
-    mkdir(bin_dir)
-    py_executable = join(bin_dir, os.path.basename(sys.executable))
-    if 'Python.framework' in prefix:
-        # OS X framework builds cause validation to break
-        # https://github.com/pypa/virtualenv/issues/322
-        if os.environ.get('__PYVENV_LAUNCHER__'):
-          os.unsetenv('__PYVENV_LAUNCHER__')
-        if re.search(r'/Python(?:-32|-64)*$', py_executable):
-            # The name of the python executable is not quite what
-            # we want, rename it.
-            py_executable = os.path.join(
-                    os.path.dirname(py_executable), 'python')
-
-    logger.notify('New %s executable in %s', expected_exe, py_executable)
-    pcbuild_dir = os.path.dirname(sys.executable)
-    pyd_pth = os.path.join(lib_dir, 'site-packages', 'virtualenv_builddir_pyd.pth')
-    if is_win and os.path.exists(os.path.join(pcbuild_dir, 'build.bat')):
-        logger.notify('Detected python running from build directory %s', pcbuild_dir)
-        logger.notify('Writing .pth file linking to build directory for *.pyd files')
-        writefile(pyd_pth, pcbuild_dir)
-    else:
-        pcbuild_dir = None
-        if os.path.exists(pyd_pth):
-            logger.info('Deleting %s (not Windows env or not build directory python)' % pyd_pth)
-            os.unlink(pyd_pth)
-
-    if sys.executable != py_executable:
-        ## FIXME: could I just hard link?
-        executable = sys.executable
-        shutil.copyfile(executable, py_executable)
-        make_exe(py_executable)
-        if is_win or is_cygwin:
-            pythonw = os.path.join(os.path.dirname(sys.executable), 'pythonw.exe')
-            if os.path.exists(pythonw):
-                logger.info('Also created pythonw.exe')
-                shutil.copyfile(pythonw, os.path.join(os.path.dirname(py_executable), 'pythonw.exe'))
-            python_d = os.path.join(os.path.dirname(sys.executable), 'python_d.exe')
-            python_d_dest = os.path.join(os.path.dirname(py_executable), 'python_d.exe')
-            if os.path.exists(python_d):
-                logger.info('Also created python_d.exe')
-                shutil.copyfile(python_d, python_d_dest)
-            elif os.path.exists(python_d_dest):
-                logger.info('Removed python_d.exe as it is no longer at the source')
-                os.unlink(python_d_dest)
-            # we need to copy the DLL to enforce that windows will load the correct one.
-            # may not exist if we are cygwin.
-            py_executable_dll = 'python%s%s.dll' % (
-                sys.version_info[0], sys.version_info[1])
-            py_executable_dll_d = 'python%s%s_d.dll' % (
-                sys.version_info[0], sys.version_info[1])
-            pythondll = os.path.join(os.path.dirname(sys.executable), py_executable_dll)
-            pythondll_d = os.path.join(os.path.dirname(sys.executable), py_executable_dll_d)
-            pythondll_d_dest = os.path.join(os.path.dirname(py_executable), py_executable_dll_d)
-            if os.path.exists(pythondll):
-                logger.info('Also created %s' % py_executable_dll)
-                shutil.copyfile(pythondll, os.path.join(os.path.dirname(py_executable), py_executable_dll))
-            if os.path.exists(pythondll_d):
-                logger.info('Also created %s' % py_executable_dll_d)
-                shutil.copyfile(pythondll_d, pythondll_d_dest)
-            elif os.path.exists(pythondll_d_dest):
-                logger.info('Removed %s as the source does not exist' % pythondll_d_dest)
-                os.unlink(pythondll_d_dest)
-        if is_pypy:
-            # make a symlink python --> pypy-c
-            python_executable = os.path.join(os.path.dirname(py_executable), 'python')
-            if sys.platform in ('win32', 'cygwin'):
-                python_executable += '.exe'
-            logger.info('Also created executable %s' % python_executable)
-            copyfile(py_executable, python_executable)
-
-            if is_win:
-                for name in 'libexpat.dll', 'libpypy.dll', 'libpypy-c.dll', 'libeay32.dll', 'ssleay32.dll', 'sqlite.dll':
-                    src = join(prefix, name)
-                    if os.path.exists(src):
-                        copyfile(src, join(bin_dir, name))
-
-    if os.path.splitext(os.path.basename(py_executable))[0] != expected_exe:
-        secondary_exe = os.path.join(os.path.dirname(py_executable),
-                                     expected_exe)
-        py_executable_ext = os.path.splitext(py_executable)[1]
-        if py_executable_ext == '.exe':
-            # python2.4 gives an extension of '.4' :P
-            secondary_exe += py_executable_ext
-        if os.path.exists(secondary_exe):
-            logger.warn('Not overwriting existing %s script %s (you must use %s)'
-                        % (expected_exe, secondary_exe, py_executable))
-        else:
-            logger.notify('Also creating executable in %s' % secondary_exe)
-            shutil.copyfile(sys.executable, secondary_exe)
-            make_exe(secondary_exe)
-
-    if '.framework' in prefix:
-        if 'Python.framework' in prefix:
-            logger.debug('MacOSX Python framework detected')
-            # Make sure we use the the embedded interpreter inside
-            # the framework, even if sys.executable points to
-            # the stub executable in ${sys.prefix}/bin
-            # See http://groups.google.com/group/python-virtualenv/
-            #                              browse_thread/thread/17cab2f85da75951
-            original_python = os.path.join(
-                prefix, 'Resources/Python.app/Contents/MacOS/Python')
-        if 'EPD' in prefix:
-            logger.debug('EPD framework detected')
-            original_python = os.path.join(prefix, 'bin/python')
-        shutil.copy(original_python, py_executable)
-
-        # Copy the framework's dylib into the virtual
-        # environment
-        virtual_lib = os.path.join(home_dir, '.Python')
-
-        if os.path.exists(virtual_lib):
-            os.unlink(virtual_lib)
-        copyfile(
-            os.path.join(prefix, 'Python'),
-            virtual_lib)
-
-        # And then change the install_name of the copied python executable
-        try:
-            mach_o_change(py_executable,
-                          os.path.join(prefix, 'Python'),
-                          '@executable_path/../.Python')
-        except:
-            e = sys.exc_info()[1]
-            logger.warn("Could not call mach_o_change: %s. "
-                        "Trying to call install_name_tool instead." % e)
-            try:
-                call_subprocess(
-                    ["install_name_tool", "-change",
-                     os.path.join(prefix, 'Python'),
-                     '@executable_path/../.Python',
-                     py_executable])
-            except:
-                logger.fatal("Could not call install_name_tool -- you must "
-                             "have Apple's development tools installed")
-                raise
-
-    if not is_win:
-        # Ensure that 'python', 'pythonX' and 'pythonX.Y' all exist
-        py_exe_version_major = 'python%s' % sys.version_info[0]
-        py_exe_version_major_minor = 'python%s.%s' % (
-            sys.version_info[0], sys.version_info[1])
-        py_exe_no_version = 'python'
-        required_symlinks = [ py_exe_no_version, py_exe_version_major,
-                         py_exe_version_major_minor ]
-
-        py_executable_base = os.path.basename(py_executable)
-
-        if py_executable_base in required_symlinks:
-            # Don't try to symlink to yourself.
-            required_symlinks.remove(py_executable_base)
-
-        for pth in required_symlinks:
-            full_pth = join(bin_dir, pth)
-            if os.path.exists(full_pth):
-                os.unlink(full_pth)
-            os.symlink(py_executable_base, full_pth)
-
-    if is_win and ' ' in py_executable:
-        # There's a bug with subprocess on Windows when using a first
-        # argument that has a space in it.  Instead we have to quote
-        # the value:
-        py_executable = '"%s"' % py_executable
-    # NOTE: keep this check as one line, cmd.exe doesn't cope with line breaks
-    cmd = [py_executable, '-c', 'import sys;out=sys.stdout;'
-        'getattr(out, "buffer", out).write(sys.prefix.encode("utf-8"))']
-    logger.info('Testing executable with %s %s "%s"' % tuple(cmd))
-    try:
-        proc = subprocess.Popen(cmd,
-                            stdout=subprocess.PIPE)
-        proc_stdout, proc_stderr = proc.communicate()
-    except OSError:
-        e = sys.exc_info()[1]
-        if e.errno == errno.EACCES:
-            logger.fatal('ERROR: The executable %s could not be run: %s' % (py_executable, e))
-            sys.exit(100)
-        else:
-            raise e
-
-    proc_stdout = proc_stdout.strip().decode("utf-8")
-    proc_stdout = os.path.normcase(os.path.abspath(proc_stdout))
-    norm_home_dir = os.path.normcase(os.path.abspath(home_dir))
-    if hasattr(norm_home_dir, 'decode'):
-        norm_home_dir = norm_home_dir.decode(sys.getfilesystemencoding())
-    if proc_stdout != norm_home_dir:
-        logger.fatal(
-            'ERROR: The executable %s is not functioning' % py_executable)
-        logger.fatal(
-            'ERROR: It thinks sys.prefix is %r (should be %r)'
-            % (proc_stdout, norm_home_dir))
-        logger.fatal(
-            'ERROR: virtualenv is not compatible with this system or executable')
-        if is_win:
-            logger.fatal(
-                'Note: some Windows users have reported this error when they '
-                'installed Python for "Only this user" or have multiple '
-                'versions of Python installed. Copying the appropriate '
-                'PythonXX.dll to the virtualenv Scripts/ directory may fix '
-                'this problem.')
-        sys.exit(100)
-    else:
-        logger.info('Got sys.prefix result: %r' % proc_stdout)
-
-    pydistutils = os.path.expanduser('~/.pydistutils.cfg')
-    if os.path.exists(pydistutils):
-        logger.notify('Please make sure you remove any previous custom paths from '
-                      'your %s file.' % pydistutils)
-    ## FIXME: really this should be calculated earlier
-
-    fix_local_scheme(home_dir)
-
-    if site_packages:
-        if os.path.exists(site_packages_filename):
-            logger.info('Deleting %s' % site_packages_filename)
-            os.unlink(site_packages_filename)
-
-    return py_executable
-
-
-def install_activate(home_dir, bin_dir, prompt=None):
-    home_dir = os.path.abspath(home_dir)
-    if is_win or is_jython and os._name == 'nt':
-        files = {
-            'activate.bat': ACTIVATE_BAT,
-            'deactivate.bat': DEACTIVATE_BAT,
-            'activate.ps1': ACTIVATE_PS,
-        }
-
-        # MSYS needs paths of the form /c/path/to/file
-        drive, tail = os.path.splitdrive(home_dir.replace(os.sep, '/'))
-        home_dir_msys = (drive and "/%s%s" or "%s%s") % (drive[:1], tail)
-
-        # Run-time conditional enables (basic) Cygwin compatibility
-        home_dir_sh = ("""$(if [ "$OSTYPE" "==" "cygwin" ]; then cygpath -u '%s'; else echo '%s'; fi;)""" %
-                       (home_dir, home_dir_msys))
-        files['activate'] = ACTIVATE_SH.replace('__VIRTUAL_ENV__', home_dir_sh)
-
-    else:
-        files = {'activate': ACTIVATE_SH}
-
-        # suppling activate.fish in addition to, not instead of, the
-        # bash script support.
-        files['activate.fish'] = ACTIVATE_FISH
-
-        # same for csh/tcsh support...
-        files['activate.csh'] = ACTIVATE_CSH
-
-    files['activate_this.py'] = ACTIVATE_THIS
-    if hasattr(home_dir, 'decode'):
-        home_dir = home_dir.decode(sys.getfilesystemencoding())
-    vname = os.path.basename(home_dir)
-    for name, content in files.items():
-        content = content.replace('__VIRTUAL_PROMPT__', prompt or '')
-        content = content.replace('__VIRTUAL_WINPROMPT__', prompt or '(%s)' % vname)
-        content = content.replace('__VIRTUAL_ENV__', home_dir)
-        content = content.replace('__VIRTUAL_NAME__', vname)
-        content = content.replace('__BIN_NAME__', os.path.basename(bin_dir))
-        writefile(os.path.join(bin_dir, name), content)
-
-def install_distutils(home_dir):
-    distutils_path = change_prefix(distutils.__path__[0], home_dir)
-    mkdir(distutils_path)
-    ## FIXME: maybe this prefix setting should only be put in place if
-    ## there's a local distutils.cfg with a prefix setting?
-    home_dir = os.path.abspath(home_dir)
-    ## FIXME: this is breaking things, removing for now:
-    #distutils_cfg = DISTUTILS_CFG + "\n[install]\nprefix=%s\n" % home_dir
-    writefile(os.path.join(distutils_path, '__init__.py'), DISTUTILS_INIT)
-    writefile(os.path.join(distutils_path, 'distutils.cfg'), DISTUTILS_CFG, overwrite=False)
-
-def fix_local_scheme(home_dir):
-    """
-    Platforms that use the "posix_local" install scheme (like Ubuntu with
-    Python 2.7) need to be given an additional "local" location, sigh.
-    """
-    try:
-        import sysconfig
-    except ImportError:
-        pass
-    else:
-        if sysconfig._get_default_scheme() == 'posix_local':
-            local_path = os.path.join(home_dir, 'local')
-            if not os.path.exists(local_path):
-                os.mkdir(local_path)
-                for subdir_name in os.listdir(home_dir):
-                    if subdir_name == 'local':
-                        continue
-                    os.symlink(os.path.abspath(os.path.join(home_dir, subdir_name)), \
-                                                            os.path.join(local_path, subdir_name))
-
-def fix_lib64(lib_dir):
-    """
-    Some platforms (particularly Gentoo on x64) put things in lib64/pythonX.Y
-    instead of lib/pythonX.Y.  If this is such a platform we'll just create a
-    symlink so lib64 points to lib
-    """
-    if [p for p in distutils.sysconfig.get_config_vars().values()
-        if isinstance(p, basestring) and 'lib64' in p]:
-        logger.debug('This system uses lib64; symlinking lib64 to lib')
-        assert os.path.basename(lib_dir) == 'python%s' % sys.version[:3], (
-            "Unexpected python lib dir: %r" % lib_dir)
-        lib_parent = os.path.dirname(lib_dir)
-        top_level = os.path.dirname(lib_parent)
-        lib_dir = os.path.join(top_level, 'lib')
-        lib64_link = os.path.join(top_level, 'lib64')
-        assert os.path.basename(lib_parent) == 'lib', (
-            "Unexpected parent dir: %r" % lib_parent)
-        if os.path.lexists(lib64_link):
-            return
-        os.symlink('lib', lib64_link)
-
-def resolve_interpreter(exe):
-    """
-    If the executable given isn't an absolute path, search $PATH for the interpreter
-    """
-    if os.path.abspath(exe) != exe:
-        paths = os.environ.get('PATH', '').split(os.pathsep)
-        for path in paths:
-            if os.path.exists(os.path.join(path, exe)):
-                exe = os.path.join(path, exe)
-                break
-    if not os.path.exists(exe):
-        logger.fatal('The executable %s (from --python=%s) does not exist' % (exe, exe))
-        raise SystemExit(3)
-    if not is_executable(exe):
-        logger.fatal('The executable %s (from --python=%s) is not executable' % (exe, exe))
-        raise SystemExit(3)
-    return exe
-
-def is_executable(exe):
-    """Checks a file is executable"""
-    return os.access(exe, os.X_OK)
-
-############################################################
-## Relocating the environment:
-
-def make_environment_relocatable(home_dir):
-    """
-    Makes the already-existing environment use relative paths, and takes out
-    the #!-based environment selection in scripts.
-    """
-    home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir)
-    activate_this = os.path.join(bin_dir, 'activate_this.py')
-    if not os.path.exists(activate_this):
-        logger.fatal(
-            'The environment doesn\'t have a file %s -- please re-run virtualenv '
-            'on this environment to update it' % activate_this)
-    fixup_scripts(home_dir)
-    fixup_pth_and_egg_link(home_dir)
-    ## FIXME: need to fix up distutils.cfg
-
-OK_ABS_SCRIPTS = ['python', 'python%s' % sys.version[:3],
-                  'activate', 'activate.bat', 'activate_this.py']
-
-def fixup_scripts(home_dir):
-    # This is what we expect at the top of scripts:
-    shebang = '#!%s/bin/python' % os.path.normcase(os.path.abspath(home_dir))
-    # This is what we'll put:
-    new_shebang = '#!/usr/bin/env python%s' % sys.version[:3]
-    if is_win:
-        bin_suffix = 'Scripts'
-    else:
-        bin_suffix = 'bin'
-    bin_dir = os.path.join(home_dir, bin_suffix)
-    home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir)
-    for filename in os.listdir(bin_dir):
-        filename = os.path.join(bin_dir, filename)
-        if not os.path.isfile(filename):
-            # ignore subdirs, e.g. .svn ones.
-            continue
-        f = open(filename, 'rb')
-        try:
-            try:
-                lines = f.read().decode('utf-8').splitlines()
-            except UnicodeDecodeError:
-                # This is probably a binary program instea