1 #!/usr/bin/env python

     2 """Create a "virtual" Python installation

     3 """

     4 

     5 __version__ = "13.0.1"

     6 virtualenv_version = __version__  # legacy

     7 

     8 import base64

     9 import sys

    10 import os

    11 import codecs

    12 import optparse

    13 import re

    14 import shutil

    15 import logging

    16 import tempfile

    17 import zlib

    18 import errno

    19 import glob

    20 import distutils.sysconfig

    21 from distutils.util import strtobool

    22 import struct

    23 import subprocess

    24 import tarfile

    25 

    26 if sys.version_info < (2, 6):

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

    28     print('ERROR: this script requires Python 2.6 or greater.')

    29     sys.exit(101)

    30 

    31 try:

    32     basestring

    33 except NameError:

    34     basestring = str

    35 

    36 try:

    37     import ConfigParser

    38 except ImportError:

    39     import configparser as ConfigParser

    40 

    41 join = os.path.join

    42 py_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])

    43 

    44 is_jython = sys.platform.startswith('java')

    45 is_pypy = hasattr(sys, 'pypy_version_info')

    46 is_win = (sys.platform == 'win32')

    47 is_cygwin = (sys.platform == 'cygwin')

    48 is_darwin = (sys.platform == 'darwin')

    49 abiflags = getattr(sys, 'abiflags', '')

    50 

    51 user_dir = os.path.expanduser('~')

    52 if is_win:

    53     default_storage_dir = os.path.join(user_dir, 'virtualenv')

    54 else:

    55     default_storage_dir = os.path.join(user_dir, '.virtualenv')

    56 default_config_file = os.path.join(default_storage_dir, 'virtualenv.ini')

    57 

    58 if is_pypy:

    59     expected_exe = 'pypy'

    60 elif is_jython:

    61     expected_exe = 'jython'

    62 else:

    63     expected_exe = 'python'

    64 

    65 # Return a mapping of version -> Python executable

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

    67 if not is_win:

    68     def get_installed_pythons():

    69         return {}

    70 else:

    71     try:

    72         import winreg

    73     except ImportError:

    74         import _winreg as winreg

    75 

    76     def get_installed_pythons():

    77         try:

    78             python_core = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE,

    79                     "Software\\Python\\PythonCore")

    80         except WindowsError:

    81             # No registered Python installations

    82             return {}

    83         i = 0

    84         versions = []

    85         while True:

    86             try:

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

    88                 i = i + 1

    89             except WindowsError:

    90                 break

    91         exes = dict()

    92         for ver in versions:

    93             try:

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

    95             except WindowsError:

    96                 continue

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

    98 

    99         winreg.CloseKey(python_core)

   100 

   101         # Add the major versions

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

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

   104         for ver in sorted(exes):

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

   106 

   107         return exes

   108 

   109 REQUIRED_MODULES = ['os', 'posix', 'posixpath', 'nt', 'ntpath', 'genericpath',

   110                     'fnmatch', 'locale', 'encodings', 'codecs',

   111                     'stat', 'UserDict', 'readline', 'copy_reg', 'types',

   112                     're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',

   113                     'zlib']

   114 

   115 REQUIRED_FILES = ['lib-dynload', 'config']

   116 

   117 majver, minver = sys.version_info[:2]

   118 if majver == 2:

   119     if minver >= 6:

   120         REQUIRED_MODULES.extend(['warnings', 'linecache', '_abcoll', 'abc'])

   121     if minver >= 7:

   122         REQUIRED_MODULES.extend(['_weakrefset'])

   123 elif majver == 3:

   124     # Some extra modules are needed for Python 3, but different ones

   125     # for different versions.

   126     REQUIRED_MODULES.extend(['_abcoll', 'warnings', 'linecache', 'abc', 'io',

   127                              '_weakrefset', 'copyreg', 'tempfile', 'random',

   128                              '__future__', 'collections', 'keyword', 'tarfile',

   129                              'shutil', 'struct', 'copy', 'tokenize', 'token',

   130                              'functools', 'heapq', 'bisect', 'weakref',

   131                              'reprlib'])

   132     if minver >= 2:

   133         REQUIRED_FILES[-1] = 'config-%s' % majver

   134     if minver >= 3:

   135         import sysconfig

   136         platdir = sysconfig.get_config_var('PLATDIR')

   137         REQUIRED_FILES.append(platdir)

   138         # The whole list of 3.3 modules is reproduced below - the current

   139         # uncommented ones are required for 3.3 as of now, but more may be

   140         # added as 3.3 development continues.

   141         REQUIRED_MODULES.extend([

   142             #"aifc",

   143             #"antigravity",

   144             #"argparse",

   145             #"ast",

   146             #"asynchat",

   147             #"asyncore",

   148             "base64",

   149             #"bdb",

   150             #"binhex",

   151             #"bisect",

   152             #"calendar",

   153             #"cgi",

   154             #"cgitb",

   155             #"chunk",

   156             #"cmd",

   157             #"codeop",

   158             #"code",

   159             #"colorsys",

   160             #"_compat_pickle",

   161             #"compileall",

   162             #"concurrent",

   163             #"configparser",

   164             #"contextlib",

   165             #"cProfile",

   166             #"crypt",

   167             #"csv",

   168             #"ctypes",

   169             #"curses",

   170             #"datetime",

   171             #"dbm",

   172             #"decimal",

   173             #"difflib",

   174             #"dis",

   175             #"doctest",

   176             #"dummy_threading",

   177             "_dummy_thread",

   178             #"email",

   179             #"filecmp",

   180             #"fileinput",

   181             #"formatter",

   182             #"fractions",

   183             #"ftplib",

   184             #"functools",

   185             #"getopt",

   186             #"getpass",

   187             #"gettext",

   188             #"glob",

   189             #"gzip",

   190             "hashlib",

   191             #"heapq",

   192             "hmac",

   193             #"html",

   194             #"http",

   195             #"idlelib",

   196             #"imaplib",

   197             #"imghdr",

   198             "imp",

   199             "importlib",

   200             #"inspect",

   201             #"json",

   202             #"lib2to3",

   203             #"logging",

   204             #"macpath",

   205             #"macurl2path",

   206             #"mailbox",

   207             #"mailcap",

   208             #"_markupbase",

   209             #"mimetypes",

   210             #"modulefinder",

   211             #"multiprocessing",

   212             #"netrc",

   213             #"nntplib",

   214             #"nturl2path",

   215             #"numbers",

   216             #"opcode",

   217             #"optparse",

   218             #"os2emxpath",

   219             #"pdb",

   220             #"pickle",

   221             #"pickletools",

   222             #"pipes",

   223             #"pkgutil",

   224             #"platform",

   225             #"plat-linux2",

   226             #"plistlib",

   227             #"poplib",

   228             #"pprint",

   229             #"profile",

   230             #"pstats",

   231             #"pty",

   232             #"pyclbr",

   233             #"py_compile",

   234             #"pydoc_data",

   235             #"pydoc",

   236             #"_pyio",

   237             #"queue",

   238             #"quopri",

   239             #"reprlib",

   240             "rlcompleter",

   241             #"runpy",

   242             #"sched",

   243             #"shelve",

   244             #"shlex",

   245             #"smtpd",

   246             #"smtplib",

   247             #"sndhdr",

   248             #"socket",

   249             #"socketserver",

   250             #"sqlite3",

   251             #"ssl",

   252             #"stringprep",

   253             #"string",

   254             #"_strptime",

   255             #"subprocess",

   256             #"sunau",

   257             #"symbol",

   258             #"symtable",

   259             #"sysconfig",

   260             #"tabnanny",

   261             #"telnetlib",

   262             #"test",

   263             #"textwrap",

   264             #"this",

   265             #"_threading_local",

   266             #"threading",

   267             #"timeit",

   268             #"tkinter",

   269             #"tokenize",

   270             #"token",

   271             #"traceback",

   272             #"trace",

   273             #"tty",

   274             #"turtledemo",

   275             #"turtle",

   276             #"unittest",

   277             #"urllib",

   278             #"uuid",

   279             #"uu",

   280             #"wave",

   281             #"weakref",

   282             #"webbrowser",

   283             #"wsgiref",

   284             #"xdrlib",

   285             #"xml",

   286             #"xmlrpc",

   287             #"zipfile",

   288         ])

   289     if minver >= 4:

   290         REQUIRED_MODULES.extend([

   291             'operator',

   292             '_collections_abc',

   293             '_bootlocale',

   294         ])

   295 

   296 if is_pypy:

   297     # these are needed to correctly display the exceptions that may happen

   298     # during the bootstrap

   299     REQUIRED_MODULES.extend(['traceback', 'linecache'])

   300 

   301 class Logger(object):

   302 

   303     """

   304     Logging object for use in command-line script.  Allows ranges of

   305     levels, to avoid some redundancy of displayed information.

   306     """

   307 

   308     DEBUG = logging.DEBUG

   309     INFO = logging.INFO

   310     NOTIFY = (logging.INFO+logging.WARN)/2

   311     WARN = WARNING = logging.WARN

   312     ERROR = logging.ERROR

   313     FATAL = logging.FATAL

   314 

   315     LEVELS = [DEBUG, INFO, NOTIFY, WARN, ERROR, FATAL]

   316 

   317     def __init__(self, consumers):

   318         self.consumers = consumers

   319         self.indent = 0

   320         self.in_progress = None

   321         self.in_progress_hanging = False

   322 

   323     def debug(self, msg, *args, **kw):

   324         self.log(self.DEBUG, msg, *args, **kw)

   325     def info(self, msg, *args, **kw):

   326         self.log(self.INFO, msg, *args, **kw)

   327     def notify(self, msg, *args, **kw):

   328         self.log(self.NOTIFY, msg, *args, **kw)

   329     def warn(self, msg, *args, **kw):

   330         self.log(self.WARN, msg, *args, **kw)

   331     def error(self, msg, *args, **kw):

   332         self.log(self.ERROR, msg, *args, **kw)

   333     def fatal(self, msg, *args, **kw):

   334         self.log(self.FATAL, msg, *args, **kw)

   335     def log(self, level, msg, *args, **kw):

   336         if args:

   337             if kw:

   338                 raise TypeError(

   339                     "You may give positional or keyword arguments, not both")

   340         args = args or kw

   341         rendered = None

   342         for consumer_level, consumer in self.consumers:

   343             if self.level_matches(level, consumer_level):

   344                 if (self.in_progress_hanging

   345                     and consumer in (sys.stdout, sys.stderr)):

   346                     self.in_progress_hanging = False

   347                     sys.stdout.write('\n')

   348                     sys.stdout.flush()

   349                 if rendered is None:

   350                     if args:

   351                         rendered = msg % args

   352                     else:

   353                         rendered = msg

   354                     rendered = ' '*self.indent + rendered

   355                 if hasattr(consumer, 'write'):

   356                     consumer.write(rendered+'\n')

   357                 else:

   358                     consumer(rendered)

   359 

   360     def start_progress(self, msg):

   361         assert not self.in_progress, (

   362             "Tried to start_progress(%r) while in_progress %r"

   363             % (msg, self.in_progress))

   364         if self.level_matches(self.NOTIFY, self._stdout_level()):

   365             sys.stdout.write(msg)

   366             sys.stdout.flush()

   367             self.in_progress_hanging = True

   368         else:

   369             self.in_progress_hanging = False

   370         self.in_progress = msg

   371 

   372     def end_progress(self, msg='done.'):

   373         assert self.in_progress, (

   374             "Tried to end_progress without start_progress")

   375         if self.stdout_level_matches(self.NOTIFY):

   376             if not self.in_progress_hanging:

   377                 # Some message has been printed out since start_progress

   378                 sys.stdout.write('...' + self.in_progress + msg + '\n')

   379                 sys.stdout.flush()

   380             else:

   381                 sys.stdout.write(msg + '\n')

   382                 sys.stdout.flush()

   383         self.in_progress = None

   384         self.in_progress_hanging = False

   385 

   386     def show_progress(self):

   387         """If we are in a progress scope, and no log messages have been

   388         shown, write out another '.'"""

   389         if self.in_progress_hanging:

   390             sys.stdout.write('.')

   391             sys.stdout.flush()

   392 

   393     def stdout_level_matches(self, level):

   394         """Returns true if a message at this level will go to stdout"""

   395         return self.level_matches(level, self._stdout_level())

   396 

   397     def _stdout_level(self):

   398         """Returns the level that stdout runs at"""

   399         for level, consumer in self.consumers:

   400             if consumer is sys.stdout:

   401                 return level

   402         return self.FATAL

   403 

   404     def level_matches(self, level, consumer_level):

   405         """

   406         >>> l = Logger([])

   407         >>> l.level_matches(3, 4)

   408         False

   409         >>> l.level_matches(3, 2)

   410         True

   411         >>> l.level_matches(slice(None, 3), 3)

   412         False

   413         >>> l.level_matches(slice(None, 3), 2)

   414         True

   415         >>> l.level_matches(slice(1, 3), 1)

   416         True

   417         >>> l.level_matches(slice(2, 3), 1)

   418         False

   419         """

   420         if isinstance(level, slice):

   421             start, stop = level.start, level.stop

   422             if start is not None and start > consumer_level:

   423                 return False

   424             if stop is not None and stop <= consumer_level:

   425                 return False

   426             return True

   427         else:

   428             return level >= consumer_level

   429 

   430     #@classmethod

   431     def level_for_integer(cls, level):

   432         levels = cls.LEVELS

   433         if level < 0:

   434             return levels[0]

   435         if level >= len(levels):

   436             return levels[-1]

   437         return levels[level]

   438 

   439     level_for_integer = classmethod(level_for_integer)

   440 

   441 # create a silent logger just to prevent this from being undefined

   442 # will be overridden with requested verbosity main() is called.

   443 logger = Logger([(Logger.LEVELS[-1], sys.stdout)])

   444 

   445 def mkdir(path):

   446     if not os.path.exists(path):

   447         logger.info('Creating %s', path)

   448         os.makedirs(path)

   449     else:

   450         logger.info('Directory %s already exists', path)

   451 

   452 def copyfileordir(src, dest, symlink=True):

   453     if os.path.isdir(src):

   454         shutil.copytree(src, dest, symlink)

   455     else:

   456         shutil.copy2(src, dest)

   457 

   458 def copyfile(src, dest, symlink=True):

   459     if not os.path.exists(src):

   460         # Some bad symlink in the src

   461         logger.warn('Cannot find file %s (bad symlink)', src)

   462         return

   463     if os.path.exists(dest):

   464         logger.debug('File %s already exists', dest)

   465         return

   466     if not os.path.exists(os.path.dirname(dest)):

   467         logger.info('Creating parent directories for %s', os.path.dirname(dest))

   468         os.makedirs(os.path.dirname(dest))

   469     if not os.path.islink(src):

   470         srcpath = os.path.abspath(src)

   471     else:

   472         srcpath = os.readlink(src)

   473     if symlink and hasattr(os, 'symlink') and not is_win:

   474         logger.info('Symlinking %s', dest)

   475         try:

   476             os.symlink(srcpath, dest)

   477         except (OSError, NotImplementedError):

   478             logger.info('Symlinking failed, copying to %s', dest)

   479             copyfileordir(src, dest, symlink)

   480     else:

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

   482         copyfileordir(src, dest, symlink)

   483 

   484 def writefile(dest, content, overwrite=True):

   485     if not os.path.exists(dest):

   486         logger.info('Writing %s', dest)

   487         f = open(dest, 'wb')

   488         f.write(content.encode('utf-8'))

   489         f.close()

   490         return

   491     else:

   492         f = open(dest, 'rb')

   493         c = f.read()

   494         f.close()

   495         if c != content.encode("utf-8"):

   496             if not overwrite:

   497                 logger.notify('File %s exists with different content; not overwriting', dest)

   498                 return

   499             logger.notify('Overwriting %s with new content', dest)

   500             f = open(dest, 'wb')

   501             f.write(content.encode('utf-8'))

   502             f.close()

   503         else:

   504             logger.info('Content %s already in place', dest)

   505 

   506 def rmtree(dir):

   507     if os.path.exists(dir):

   508         logger.notify('Deleting tree %s', dir)

   509         shutil.rmtree(dir)

   510     else:

   511         logger.info('Do not need to delete %s; already gone', dir)

   512 

   513 def make_exe(fn):

   514     if hasattr(os, 'chmod'):

   515         oldmode = os.stat(fn).st_mode & 0xFFF # 0o7777

   516         newmode = (oldmode | 0x16D) & 0xFFF # 0o555, 0o7777

   517         os.chmod(fn, newmode)

   518         logger.info('Changed mode of %s to %s', fn, oct(newmode))

   519 

   520 def _find_file(filename, dirs):

   521     for dir in reversed(dirs):

   522         files = glob.glob(os.path.join(dir, filename))

   523         if files and os.path.isfile(files[0]):

   524             return True, files[0]

   525     return False, filename

   526 

   527 def file_search_dirs():

   528     here = os.path.dirname(os.path.abspath(__file__))

   529     dirs = [here, join(here, 'virtualenv_support')]

   530     if os.path.splitext(os.path.dirname(__file__))[0] != 'virtualenv':

   531         # Probably some boot script; just in case virtualenv is installed...

   532         try:

   533             import virtualenv

   534         except ImportError:

   535             pass

   536         else:

   537             dirs.append(os.path.join(

   538                 os.path.dirname(virtualenv.__file__), 'virtualenv_support'))

   539     return [d for d in dirs if os.path.isdir(d)]

   540 

   541 

   542 class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):

   543     """

   544     Custom help formatter for use in ConfigOptionParser that updates

   545     the defaults before expanding them, allowing them to show up correctly

   546     in the help listing

   547     """

   548     def expand_default(self, option):

   549         if self.parser is not None:

   550             self.parser.update_defaults(self.parser.defaults)

   551         return optparse.IndentedHelpFormatter.expand_default(self, option)

   552 

   553 

   554 class ConfigOptionParser(optparse.OptionParser):

   555     """

   556     Custom option parser which updates its defaults by checking the

   557     configuration files and environmental variables

   558     """

   559     def __init__(self, *args, **kwargs):

   560         self.config = ConfigParser.RawConfigParser()

   561         self.files = self.get_config_files()

   562         self.config.read(self.files)

   563         optparse.OptionParser.__init__(self, *args, **kwargs)

   564 

   565     def get_config_files(self):

   566         config_file = os.environ.get('VIRTUALENV_CONFIG_FILE', False)

   567         if config_file and os.path.exists(config_file):

   568             return [config_file]

   569         return [default_config_file]

   570 

   571     def update_defaults(self, defaults):

   572         """

   573         Updates the given defaults with values from the config files and

   574         the environ. Does a little special handling for certain types of

   575         options (lists).

   576         """

   577         # Then go and look for the other sources of configuration:

   578         config = {}

   579         # 1. config files

   580         config.update(dict(self.get_config_section('virtualenv')))

   581         # 2. environmental variables

   582         config.update(dict(self.get_environ_vars()))

   583         # Then set the options with those values

   584         for key, val in config.items():

   585             key = key.replace('_', '-')

   586             if not key.startswith('--'):

   587                 key = '--%s' % key  # only prefer long opts

   588             option = self.get_option(key)

   589             if option is not None:

   590                 # ignore empty values

   591                 if not val:

   592                     continue

   593                 # handle multiline configs

   594                 if option.action == 'append':

   595                     val = val.split()

   596                 else:

   597                     option.nargs = 1

   598                 if option.action == 'store_false':

   599                     val = not strtobool(val)

   600                 elif option.action in ('store_true', 'count'):

   601                     val = strtobool(val)

   602                 try:

   603                     val = option.convert_value(key, val)

   604                 except optparse.OptionValueError:

   605                     e = sys.exc_info()[1]

   606                     print("An error occurred during configuration: %s" % e)

   607                     sys.exit(3)

   608                 defaults[option.dest] = val

   609         return defaults

   610 

   611     def get_config_section(self, name):

   612         """

   613         Get a section of a configuration

   614         """

   615         if self.config.has_section(name):

   616             return self.config.items(name)

   617         return []

   618 

   619     def get_environ_vars(self, prefix='VIRTUALENV_'):

   620         """

   621         Returns a generator with all environmental vars with prefix VIRTUALENV

   622         """

   623         for key, val in os.environ.items():

   624             if key.startswith(prefix):

   625                 yield (key.replace(prefix, '').lower(), val)

   626 

   627     def get_default_values(self):

   628         """

   629         Overridding to make updating the defaults after instantiation of

   630         the option parser possible, update_defaults() does the dirty work.

   631         """

   632         if not self.process_default_values:

   633             # Old, pre-Optik 1.5 behaviour.

   634             return optparse.Values(self.defaults)

   635 

   636         defaults = self.update_defaults(self.defaults.copy())  # ours

   637         for option in self._get_all_options():

   638             default = defaults.get(option.dest)

   639             if isinstance(default, basestring):

   640                 opt_str = option.get_opt_string()

   641                 defaults[option.dest] = option.check_value(opt_str, default)

   642         return optparse.Values(defaults)

   643 

   644 

   645 def main():

   646     parser = ConfigOptionParser(

   647         version=virtualenv_version,

   648         usage="%prog [OPTIONS] DEST_DIR",

   649         formatter=UpdatingDefaultsHelpFormatter())

   650 

   651     parser.add_option(

   652         '-v', '--verbose',

   653         action='count',

   654         dest='verbose',

   655         default=0,

   656         help="Increase verbosity.")

   657 

   658     parser.add_option(

   659         '-q', '--quiet',

   660         action='count',

   661         dest='quiet',

   662         default=0,

   663         help='Decrease verbosity.')

   664 

   665     parser.add_option(

   666         '-p', '--python',

   667         dest='python',

   668         metavar='PYTHON_EXE',

   669         help='The Python interpreter to use, e.g., --python=python2.5 will use the python2.5 '

   670         'interpreter to create the new environment.  The default is the interpreter that '

   671         'virtualenv was installed with (%s)' % sys.executable)

   672 

   673     parser.add_option(

   674         '--clear',

   675         dest='clear',

   676         action='store_true',

   677         help="Clear out the non-root install and start from scratch.")

   678 

   679     parser.set_defaults(system_site_packages=False)

   680     parser.add_option(

   681         '--no-site-packages',

   682         dest='system_site_packages',

   683         action='store_false',

   684         help="DEPRECATED. Retained only for backward compatibility. "

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

   686 

   687     parser.add_option(

   688         '--system-site-packages',

   689         dest='system_site_packages',

   690         action='store_true',

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

   692 

   693     parser.add_option(

   694         '--always-copy',

   695         dest='symlink',

   696         action='store_false',

   697         default=True,

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

   699 

   700     parser.add_option(

   701         '--unzip-setuptools',

   702         dest='unzip_setuptools',

   703         action='store_true',

   704         help="Unzip Setuptools when installing it.")

   705 

   706     parser.add_option(

   707         '--relocatable',

   708         dest='relocatable',

   709         action='store_true',

   710         help='Make an EXISTING virtualenv environment relocatable. '

   711              'This fixes up scripts and makes all .pth files relative.')

   712 

   713     parser.add_option(

   714         '--no-setuptools',

   715         dest='no_setuptools',

   716         action='store_true',

   717         help='Do not install setuptools (or pip) in the new virtualenv.')

   718 

   719     parser.add_option(

   720         '--no-pip',

   721         dest='no_pip',

   722         action='store_true',

   723         help='Do not install pip in the new virtualenv.')

   724 

   725     parser.add_option(

   726         '--no-wheel',

   727         dest='no_wheel',

   728         action='store_true',

   729         help='Do not install wheel in the new virtualenv.')

   730 

   731     default_search_dirs = file_search_dirs()

   732     parser.add_option(

   733         '--extra-search-dir',

   734         dest="search_dirs",

   735         action="append",

   736         metavar='DIR',

   737         default=default_search_dirs,

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

   739               "This option can be used multiple times.")

   740 

   741     parser.add_option(

   742         '--never-download',

   743         dest="never_download",

   744         action="store_true",

   745         default=True,

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

   747               "Virtualenv never downloads pip or setuptools.")

   748 

   749     parser.add_option(

   750         '--prompt',

   751         dest='prompt',

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

   753 

   754     parser.add_option(

   755         '--setuptools',

   756         dest='setuptools',

   757         action='store_true',

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

   759 

   760     parser.add_option(

   761         '--distribute',

   762         dest='distribute',

   763         action='store_true',

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

   765 

   766     if 'extend_parser' in globals():

   767         extend_parser(parser)

   768 

   769     options, args = parser.parse_args()

   770 

   771     global logger

   772 

   773     if 'adjust_options' in globals():

   774         adjust_options(options, args)

   775 

   776     verbosity = options.verbose - options.quiet

   777     logger = Logger([(Logger.level_for_integer(2 - verbosity), sys.stdout)])

   778 

   779     if options.python and not os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'):

   780         env = os.environ.copy()

   781         interpreter = resolve_interpreter(options.python)

   782         if interpreter == sys.executable:

   783             logger.warn('Already using interpreter %s' % interpreter)

   784         else:

   785             logger.notify('Running virtualenv with interpreter %s' % interpreter)

   786             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   787             file = __file__

   788             if file.endswith('.pyc'):

   789                 file = file[:-1]

   790             popen = subprocess.Popen([interpreter, file] + sys.argv[1:], env=env)

   791             raise SystemExit(popen.wait())

   792 

   793     if not args:

   794         print('You must provide a DEST_DIR')

   795         parser.print_help()

   796         sys.exit(2)

   797     if len(args) > 1:

   798         print('There must be only one argument: DEST_DIR (you gave %s)' % (

   799             ' '.join(args)))

   800         parser.print_help()

   801         sys.exit(2)

   802 

   803     home_dir = args[0]

   804 

   805     if os.environ.get('WORKING_ENV'):

   806         logger.fatal('ERROR: you cannot run virtualenv while in a workingenv')

   807         logger.fatal('Please deactivate your workingenv, then re-run this script')

   808         sys.exit(3)

   809 

   810     if 'PYTHONHOME' in os.environ:

   811         logger.warn('PYTHONHOME is set.  You *must* activate the virtualenv before using it')

   812         del os.environ['PYTHONHOME']

   813 

   814     if options.relocatable:

   815         make_environment_relocatable(home_dir)

   816         return

   817 

   818     if not options.never_download:

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

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

   821 

   822     create_environment(home_dir,

   823                        site_packages=options.system_site_packages,

   824                        clear=options.clear,

   825                        unzip_setuptools=options.unzip_setuptools,

   826                        prompt=options.prompt,

   827                        search_dirs=options.search_dirs,

   828                        never_download=True,

   829                        no_setuptools=options.no_setuptools,

   830                        no_pip=options.no_pip,

   831                        no_wheel=options.no_wheel,

   832                        symlink=options.symlink)

   833     if 'after_install' in globals():

   834         after_install(options, home_dir)

   835 

   836 def call_subprocess(cmd, show_stdout=True,

   837                     filter_stdout=None, cwd=None,

   838                     raise_on_returncode=True, extra_env=None,

   839                     remove_from_env=None):

   840     cmd_parts = []

   841     for part in cmd:

   842         if len(part) > 45:

   843             part = part[:20]+"..."+part[-20:]

   844         if ' ' in part or '\n' in part or '"' in part or "'" in part:

   845             part = '"%s"' % part.replace('"', '\\"')

   846         if hasattr(part, 'decode'):

   847             try:

   848                 part = part.decode(sys.getdefaultencoding())

   849             except UnicodeDecodeError:

   850                 part = part.decode(sys.getfilesystemencoding())

   851         cmd_parts.append(part)

   852     cmd_desc = ' '.join(cmd_parts)

   853     if show_stdout:

   854         stdout = None

   855     else:

   856         stdout = subprocess.PIPE

   857     logger.debug("Running command %s" % cmd_desc)

   858     if extra_env or remove_from_env:

   859         env = os.environ.copy()

   860         if extra_env:

   861             env.update(extra_env)

   862         if remove_from_env:

   863             for varname in remove_from_env:

   864                 env.pop(varname, None)

   865     else:

   866         env = None

   867     try:

   868         proc = subprocess.Popen(

   869             cmd, stderr=subprocess.STDOUT, stdin=None, stdout=stdout,

   870             cwd=cwd, env=env)

   871     except Exception:

   872         e = sys.exc_info()[1]

   873         logger.fatal(

   874             "Error %s while executing command %s" % (e, cmd_desc))

   875         raise

   876     all_output = []

   877     if stdout is not None:

   878         stdout = proc.stdout

   879         encoding = sys.getdefaultencoding()

   880         fs_encoding = sys.getfilesystemencoding()

   881         while 1:

   882             line = stdout.readline()

   883             try:

   884                 line = line.decode(encoding)

   885             except UnicodeDecodeError:

   886                 line = line.decode(fs_encoding)

   887             if not line:

   888                 break

   889             line = line.rstrip()

   890             all_output.append(line)

   891             if filter_stdout:

   892                 level = filter_stdout(line)

   893                 if isinstance(level, tuple):

   894                     level, line = level

   895                 logger.log(level, line)

   896                 if not logger.stdout_level_matches(level):

   897                     logger.show_progress()

   898             else:

   899                 logger.info(line)

   900     else:

   901         proc.communicate()

   902     proc.wait()

   903     if proc.returncode:

   904         if raise_on_returncode:

   905             if all_output:

   906                 logger.notify('Complete output from command %s:' % cmd_desc)

   907                 logger.notify('\n'.join(all_output) + '\n----------------------------------------')

   908             raise OSError(

   909                 "Command %s failed with error code %s"

   910                 % (cmd_desc, proc.returncode))

   911         else:

   912             logger.warn(

   913                 "Command %s had error code %s"

   914                 % (cmd_desc, proc.returncode))

   915 

   916 def filter_install_output(line):

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

   918         return Logger.INFO

   919     return Logger.DEBUG

   920 

   921 def find_wheels(projects, search_dirs):

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

   923 

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

   925     a list of the first wheel found for each PROJECT

   926     """

   927 

   928     wheels = []

   929 

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

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

   932     # then use to install the correct version.

   933     for project in projects:

   934         for dirname in search_dirs:

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

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

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

   938             if files:

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

   940                 break

   941         else:

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

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

   944 

   945     return wheels

   946 

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

   948     if search_dirs is None:

   949         search_dirs = file_search_dirs()

   950 

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

   952     pythonpath = os.pathsep.join(wheels)

   953     findlinks = ' '.join(search_dirs)

   954 

   955     cmd = [

   956         py_executable, '-c',

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

   958     ] + project_names

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

   960     logger.indent += 2

   961     try:

   962         call_subprocess(cmd, show_stdout=False,

   963             extra_env = {

   964                 'PYTHONPATH': pythonpath,

   965                 'JYTHONPATH': pythonpath,  # for Jython < 3.x

   966                 'PIP_FIND_LINKS': findlinks,

   967                 'PIP_USE_WHEEL': '1',

   968                 'PIP_PRE': '1',

   969                 'PIP_NO_INDEX': '1'

   970             }

   971         )

   972     finally:

   973         logger.indent -= 2

   974         logger.end_progress()

   975 

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

   977                        unzip_setuptools=False,

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

   979                        no_setuptools=False, no_pip=False, no_wheel=False,

   980                        symlink=True):

   981     """

   982     Creates a new environment in ``home_dir``.

   983 

   984     If ``site_packages`` is true, then the global ``site-packages/``

   985     directory will be on the path.

   986 

   987     If ``clear`` is true (default False) then the environment will

   988     first be cleared.

   989     """

   990     home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir)

   991 

   992     py_executable = os.path.abspath(install_python(

   993         home_dir, lib_dir, inc_dir, bin_dir,

   994         site_packages=site_packages, clear=clear, symlink=symlink))

   995 

   996     install_distutils(home_dir)

   997 

   998     if not no_setuptools:

   999         to_install = ['setuptools']

  1000         if not no_pip:

  1001             to_install.append('pip')

  1002         if not no_wheel:

  1003             to_install.append('wheel')

  1004         install_wheel(to_install, py_executable, search_dirs)

  1005 

  1006     install_activate(home_dir, bin_dir, prompt)

  1007 

  1008 def is_executable_file(fpath):

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

  1010 

  1011 def path_locations(home_dir):

  1012     """Return the path locations for the environment (where libraries are,

  1013     where scripts go, etc)"""

  1014     # XXX: We'd use distutils.sysconfig.get_python_inc/lib but its

  1015     # prefix arg is broken: http://bugs.python.org/issue3386

  1016     if is_win:

  1017         # Windows has lots of problems with executables with spaces in

  1018         # the name; this function will remove them (using the ~1

  1019         # format):

  1020         mkdir(home_dir)

  1021         if ' ' in home_dir:

  1022             import ctypes

  1023             GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW

  1024             size = max(len(home_dir)+1, 256)

  1025             buf = ctypes.create_unicode_buffer(size)

  1026             try:

  1027                 u = unicode

  1028             except NameError:

  1029                 u = str

  1030             ret = GetShortPathName(u(home_dir), buf, size)

  1031             if not ret:

  1032                 print('Error: the path "%s" has a space in it' % home_dir)

  1033                 print('We could not determine the short pathname for it.')

  1034                 print('Exiting.')

  1035                 sys.exit(3)

  1036             home_dir = str(buf.value)

  1037         lib_dir = join(home_dir, 'Lib')

  1038         inc_dir = join(home_dir, 'Include')

  1039         bin_dir = join(home_dir, 'Scripts')

  1040     if is_jython:

  1041         lib_dir = join(home_dir, 'Lib')

  1042         inc_dir = join(home_dir, 'Include')

  1043         bin_dir = join(home_dir, 'bin')

  1044     elif is_pypy:

  1045         lib_dir = home_dir

  1046         inc_dir = join(home_dir, 'include')

  1047         bin_dir = join(home_dir, 'bin')

  1048     elif not is_win:

  1049         lib_dir = join(home_dir, 'lib', py_version)

  1050         multiarch_exec = '/usr/bin/multiarch-platform'

  1051         if is_executable_file(multiarch_exec):

  1052             # In Mageia (2) and Mandriva distros the include dir must be like:

  1053             # virtualenv/include/multiarch-x86_64-linux/python2.7

  1054             # instead of being virtualenv/include/python2.7

  1055             p = subprocess.Popen(multiarch_exec, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

  1056             stdout, stderr = p.communicate()

  1057             # stdout.strip is needed to remove newline character

  1058             inc_dir = join(home_dir, 'include', stdout.strip(), py_version + abiflags)

  1059         else:

  1060             inc_dir = join(home_dir, 'include', py_version + abiflags)

  1061         bin_dir = join(home_dir, 'bin')

  1062     return home_dir, lib_dir, inc_dir, bin_dir

  1063 

  1064 

  1065 def change_prefix(filename, dst_prefix):

  1066     prefixes = [sys.prefix]

  1067 

  1068     if is_darwin:

  1069         prefixes.extend((

  1070             os.path.join("/Library/Python", sys.version[:3], "site-packages"),

  1071             os.path.join(sys.prefix, "Extras", "lib", "python"),

  1072             os.path.join("~", "Library", "Python", sys.version[:3], "site-packages"),

  1073             # Python 2.6 no-frameworks

  1074             os.path.join("~", ".local", "lib","python", sys.version[:3], "site-packages"),

  1075             # System Python 2.7 on OSX Mountain Lion

  1076             os.path.join("~", "Library", "Python", sys.version[:3], "lib", "python", "site-packages")))

  1077 

  1078     if hasattr(sys, 'real_prefix'):

  1079         prefixes.append(sys.real_prefix)

  1080     if hasattr(sys, 'base_prefix'):

  1081         prefixes.append(sys.base_prefix)

  1082     prefixes = list(map(os.path.expanduser, prefixes))

  1083     prefixes = list(map(os.path.abspath, prefixes))

  1084     # Check longer prefixes first so we don't split in the middle of a filename

  1085     prefixes = sorted(prefixes, key=len, reverse=True)

  1086     filename = os.path.abspath(filename)

  1087     for src_prefix in prefixes:

  1088         if filename.startswith(src_prefix):

  1089             _, relpath = filename.split(src_prefix, 1)

  1090             if src_prefix != os.sep: # sys.prefix == "/"

  1091                 assert relpath[0] == os.sep

  1092                 relpath = relpath[1:]

  1093             return join(dst_prefix, relpath)

  1094     assert False, "Filename %s does not start with any of these prefixes: %s" % \

  1095         (filename, prefixes)

  1096 

  1097 def copy_required_modules(dst_prefix, symlink):

  1098     import imp

  1099     # If we are running under -p, we need to remove the current

  1100     # directory from sys.path temporarily here, so that we

  1101     # definitely get the modules from the site directory of

  1102     # the interpreter we are running under, not the one

  1103     # virtualenv.py is installed under (which might lead to py2/py3

  1104     # incompatibility issues)

  1105     _prev_sys_path = sys.path

  1106     if os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'):

  1107         sys.path = sys.path[1:]

  1108     try:

  1109         for modname in REQUIRED_MODULES:

  1110             if modname in sys.builtin_module_names:

  1111                 logger.info("Ignoring built-in bootstrap module: %s" % modname)

  1112                 continue

  1113             try:

  1114                 f, filename, _ = imp.find_module(modname)

  1115             except ImportError:

  1116                 logger.info("Cannot import bootstrap module: %s" % modname)

  1117             else:

  1118                 if f is not None:

  1119                     f.close()

  1120                 # special-case custom readline.so on OS X, but not for pypy:

  1121                 if modname == 'readline' and sys.platform == 'darwin' and not (

  1122                         is_pypy or filename.endswith(join('lib-dynload', 'readline.so'))):

  1123                     dst_filename = join(dst_prefix, 'lib', 'python%s' % sys.version[:3], 'readline.so')

  1124                 elif modname == 'readline' and sys.platform == 'win32':

  1125                     # special-case for Windows, where readline is not a

  1126                     # standard module, though it may have been installed in

  1127                     # site-packages by a third-party package

  1128                     pass

  1129                 else:

  1130                     dst_filename = change_prefix(filename, dst_prefix)

  1131                 copyfile(filename, dst_filename, symlink)

  1132                 if filename.endswith('.pyc'):

  1133                     pyfile = filename[:-1]

  1134                     if os.path.exists(pyfile):

  1135                         copyfile(pyfile, dst_filename[:-1], symlink)