#!/usr/bin/env python

## WARNING: This file is generated

#!/usr/bin/env python

"""Create a "virtual" Python installation

"""

__version__ = "1.11.6"

virtualenv_version = __version__ # legacy

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

import tarfile

if sys.version_info < (2, 6):

print('ERROR: %s' % sys.exc_info()[1])

print('ERROR: this script requires Python 2.6 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'

# Return a mapping of version -> Python executable

# Only provided for Windows, where the information in the registry is used

if not is_win:

def get_installed_pythons():

return {}

else:

try:

import winreg

except ImportError:

import _winreg as winreg

def get_installed_pythons():

python_core = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE,

"Software\\Python\\PythonCore")

i = 0

versions = []

while True:

try:

versions.append(winreg.EnumKey(python_core, i))

i = i + 1

except WindowsError:

break

exes = dict()

for ver in versions:

path = winreg.QueryValue(python_core, "%s\\InstallPath" % ver)

exes[ver] = join(path, "python.exe")

winreg.CloseKey(python_core)

# Add the major versions

# Sort the keys, then repeatedly update the major version entry

# Last executable (i.e., highest version) wins with this approach

for ver in sorted(exes):

exes[ver[0]] = exes[ver]

return exes

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 minver >= 4:

REQUIRED_MODULES.extend([

'operator',

'_collections_abc',

'_bootlocale',

])

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, symlink=True):

if os.path.isdir(src):

shutil.copytree(src, dest, symlink)

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, symlink)

else:

logger.info('Copying to %s', dest)

copyfileordir(src, dest, symlink)

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 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)]

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 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="DEPRECATED. Retained only for backward compatibility. "

"Not having access to global site-packages is now the default behavior.")

parser.add_option(

'--system-site-packages',

dest='system_site_packages',

action='store_true',

help="Give the virtual environment access to the global site-packages.")

parser.add_option(

'--always-copy',

dest='symlink',

action='store_false',

default=True,

help="Always copy files rather than symlinking.")

parser.add_option(

'--unzip-setuptools',

dest='unzip_setuptools',

action='store_true',

help="Unzip Setuptools 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(

'--no-setuptools',

dest='no_setuptools',

action='store_true',

help='Do not install 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.')

default_search_dirs = file_search_dirs()

parser.add_option(

'--extra-search-dir',

dest="search_dirs",

action="append",

metavar='DIR',

default=default_search_dirs,

help="Directory to look for setuptools/pip distributions in. "

"This option can be used multiple times.")

parser.add_option(

'--never-download',

dest="never_download",

action="store_true",

default=True,

help="DEPRECATED. Retained only for backward compatibility. This option has no effect. "

"Virtualenv never downloads pip or setuptools.")

parser.add_option(

'--prompt',

dest='prompt',

help='Provides an alternative prompt prefix for this environment.')

parser.add_option(

'--setuptools',

dest='setuptools',

action='store_true',

help="DEPRECATED. Retained only for backward compatibility. This option has no effect.")

parser.add_option(

'--distribute',

dest='distribute',

action='store_true',

help="DEPRECATED. Retained only for backward compatibility. This option has no effect.")

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())

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

if not options.never_download:

logger.warn('The --never-download option is for backward compatibility only.')

logger.warn('Setting it to false is no longer supported, and will be ignored.')

create_environment(home_dir,

site_packages=options.system_site_packages,

clear=options.clear,

unzip_setuptools=options.unzip_setuptools,

prompt=options.prompt,

search_dirs=options.search_dirs,

never_download=True,

no_setuptools=options.no_setuptools,

no_pip=options.no_pip,

symlink=options.symlink)

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 filter_install_output(line):

if line.strip().startswith('running'):

return Logger.INFO

return Logger.DEBUG

def find_wheels(projects, search_dirs):

"""Find wheels from which we can import PROJECTS.

Scan through SEARCH_DIRS for a wheel for each PROJECT in turn. Return

a list of the first wheel found for each PROJECT

"""

wheels = []

# Look through SEARCH_DIRS for the first suitable wheel. Don't bother

# about version checking here, as this is simply to get something we can

# then use to install the correct version.

for project in projects:

for dirname in search_dirs:

# This relies on only having "universal" wheels available.

# The pattern could be tightened to require -py2.py3-none-any.whl.

files = glob.glob(os.path.join(dirname, project + '-*.whl'))

if files:

wheels.append(os.path.abspath(files[0]))

break

else:

# We're out of luck, so quit with a suitable error

logger.fatal('Cannot find a wheel for %s' % (project,))

return wheels

def install_wheel(project_names, py_executable, search_dirs=None):

if search_dirs is None:

search_dirs = file_search_dirs()

wheels = find_wheels(['setuptools', 'pip'], search_dirs)

pythonpath = os.pathsep.join(wheels)

findlinks = ' '.join(search_dirs)

cmd = [

py_executable, '-c',

'import sys, pip; sys.exit(pip.main(["install", "--ignore-installed"] + sys.argv[1:]))',

] + project_names

logger.start_progress('Installing %s...' % (', '.join(project_names)))

logger.indent += 2

try:

call_subprocess(cmd, show_stdout=False,

extra_env = {

'PYTHONPATH': pythonpath,

'PIP_FIND_LINKS': findlinks,

'PIP_USE_WHEEL': '1',

'PIP_PRE': '1',

'PIP_NO_INDEX': '1'

}

)

finally:

logger.indent -= 2

logger.end_progress()

def create_environment(home_dir, site_packages=False, clear=False,

unzip_setuptools=False,

prompt=None, search_dirs=None, never_download=False,

no_setuptools=False, no_pip=False, symlink=True):

"""

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, symlink=symlink))

install_distutils(home_dir)

if not no_setuptools:

to_install = ['setuptools']

if not no_pip:

to_install.append('pip')

install_wheel(to_install, py_executable, search_dirs)

install_activate(home_dir, bin_dir, prompt)

def is_executable_file(fpath):

return os.path.isfile(fpath) and os.access(fpath, os.X_OK)