1 #!/usr/bin/env python2.7

     2 ## WARNING: This file is generated

     3 #!/usr/bin/env python

     4 """Create a "virtual" Python installation

     5 """

     6 

     7 # If you change the version here, change it in setup.py

     8 # and docs/conf.py as well.

     9 __version__ = "1.8.4"  # following best practices

    10 virtualenv_version = __version__  # legacy, again

    11 

    12 import base64

    13 import sys

    14 import os

    15 import codecs

    16 import optparse

    17 import re

    18 import shutil

    19 import logging

    20 import tempfile

    21 import zlib

    22 import errno

    23 import glob

    24 import distutils.sysconfig

    25 from distutils.util import strtobool

    26 import struct

    27 import subprocess

    28 

    29 if sys.version_info < (2, 5):

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

    31     print('ERROR: this script requires Python 2.5 or greater.')

    32     sys.exit(101)

    33 

    34 try:

    35     set

    36 except NameError:

    37     from sets import Set as set

    38 try:

    39     basestring

    40 except NameError:

    41     basestring = str

    42 

    43 try:

    44     import ConfigParser

    45 except ImportError:

    46     import configparser as ConfigParser

    47 

    48 join = os.path.join

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

    50 

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

    52 is_pypy = hasattr(sys, 'pypy_version_info')

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

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

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

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

    57 

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

    59 if is_win:

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

    61 else:

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

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

    64 

    65 if is_pypy:

    66     expected_exe = 'pypy'

    67 elif is_jython:

    68     expected_exe = 'jython'

    69 else:

    70     expected_exe = 'python'

    71 

    72 

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

    74                     'fnmatch', 'locale', 'encodings', 'codecs',

    75                     'stat', 'UserDict', 'readline', 'copy_reg', 'types',

    76                     're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',

    77                     'zlib']

    78 

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

    80 

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

    82 if majver == 2:

    83     if minver >= 6:

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

    85     if minver >= 7:

    86         REQUIRED_MODULES.extend(['_weakrefset'])

    87     if minver <= 3:

    88         REQUIRED_MODULES.extend(['sets', '__future__'])

    89 elif majver == 3:

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

    91     # for different versions.

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

    93                              '_weakrefset', 'copyreg', 'tempfile', 'random',

    94                              '__future__', 'collections', 'keyword', 'tarfile',

    95                              'shutil', 'struct', 'copy', 'tokenize', 'token',

    96                              'functools', 'heapq', 'bisect', 'weakref',

    97                              'reprlib'])

    98     if minver >= 2:

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

   100     if minver == 3:

   101         import sysconfig

   102         platdir = sysconfig.get_config_var('PLATDIR')

   103         REQUIRED_FILES.append(platdir)

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

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

   106         # added as 3.3 development continues.

   107         REQUIRED_MODULES.extend([

   108             #"aifc",

   109             #"antigravity",

   110             #"argparse",

   111             #"ast",

   112             #"asynchat",

   113             #"asyncore",

   114             "base64",

   115             #"bdb",

   116             #"binhex",

   117             #"bisect",

   118             #"calendar",

   119             #"cgi",

   120             #"cgitb",

   121             #"chunk",

   122             #"cmd",

   123             #"codeop",

   124             #"code",

   125             #"colorsys",

   126             #"_compat_pickle",

   127             #"compileall",

   128             #"concurrent",

   129             #"configparser",

   130             #"contextlib",

   131             #"cProfile",

   132             #"crypt",

   133             #"csv",

   134             #"ctypes",

   135             #"curses",

   136             #"datetime",

   137             #"dbm",

   138             #"decimal",

   139             #"difflib",

   140             #"dis",

   141             #"doctest",

   142             #"dummy_threading",

   143             "_dummy_thread",

   144             #"email",

   145             #"filecmp",

   146             #"fileinput",

   147             #"formatter",

   148             #"fractions",

   149             #"ftplib",

   150             #"functools",

   151             #"getopt",

   152             #"getpass",

   153             #"gettext",

   154             #"glob",

   155             #"gzip",

   156             "hashlib",

   157             #"heapq",

   158             "hmac",

   159             #"html",

   160             #"http",

   161             #"idlelib",

   162             #"imaplib",

   163             #"imghdr",

   164             "imp",

   165             "importlib",

   166             #"inspect",

   167             #"json",

   168             #"lib2to3",

   169             #"logging",

   170             #"macpath",

   171             #"macurl2path",

   172             #"mailbox",

   173             #"mailcap",

   174             #"_markupbase",

   175             #"mimetypes",

   176             #"modulefinder",

   177             #"multiprocessing",

   178             #"netrc",

   179             #"nntplib",

   180             #"nturl2path",

   181             #"numbers",

   182             #"opcode",

   183             #"optparse",

   184             #"os2emxpath",

   185             #"pdb",

   186             #"pickle",

   187             #"pickletools",

   188             #"pipes",

   189             #"pkgutil",

   190             #"platform",

   191             #"plat-linux2",

   192             #"plistlib",

   193             #"poplib",

   194             #"pprint",

   195             #"profile",

   196             #"pstats",

   197             #"pty",

   198             #"pyclbr",

   199             #"py_compile",

   200             #"pydoc_data",

   201             #"pydoc",

   202             #"_pyio",

   203             #"queue",

   204             #"quopri",

   205             #"reprlib",

   206             "rlcompleter",

   207             #"runpy",

   208             #"sched",

   209             #"shelve",

   210             #"shlex",

   211             #"smtpd",

   212             #"smtplib",

   213             #"sndhdr",

   214             #"socket",

   215             #"socketserver",

   216             #"sqlite3",

   217             #"ssl",

   218             #"stringprep",

   219             #"string",

   220             #"_strptime",

   221             #"subprocess",

   222             #"sunau",

   223             #"symbol",

   224             #"symtable",

   225             #"sysconfig",

   226             #"tabnanny",

   227             #"telnetlib",

   228             #"test",

   229             #"textwrap",

   230             #"this",

   231             #"_threading_local",

   232             #"threading",

   233             #"timeit",

   234             #"tkinter",

   235             #"tokenize",

   236             #"token",

   237             #"traceback",

   238             #"trace",

   239             #"tty",

   240             #"turtledemo",

   241             #"turtle",

   242             #"unittest",

   243             #"urllib",

   244             #"uuid",

   245             #"uu",

   246             #"wave",

   247             #"weakref",

   248             #"webbrowser",

   249             #"wsgiref",

   250             #"xdrlib",

   251             #"xml",

   252             #"xmlrpc",

   253             #"zipfile",

   254         ])

   255 

   256 if is_pypy:

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

   258     # during the bootstrap

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

   260 

   261 class Logger(object):

   262 

   263     """

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

   265     levels, to avoid some redundancy of displayed information.

   266     """

   267 

   268     DEBUG = logging.DEBUG

   269     INFO = logging.INFO

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

   271     WARN = WARNING = logging.WARN

   272     ERROR = logging.ERROR

   273     FATAL = logging.FATAL

   274 

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

   276 

   277     def __init__(self, consumers):

   278         self.consumers = consumers

   279         self.indent = 0

   280         self.in_progress = None

   281         self.in_progress_hanging = False

   282 

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

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

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

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

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

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

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

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

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

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

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

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

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

   296         if args:

   297             if kw:

   298                 raise TypeError(

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

   300         args = args or kw

   301         rendered = None

   302         for consumer_level, consumer in self.consumers:

   303             if self.level_matches(level, consumer_level):

   304                 if (self.in_progress_hanging

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

   306                     self.in_progress_hanging = False

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

   308                     sys.stdout.flush()

   309                 if rendered is None:

   310                     if args:

   311                         rendered = msg % args

   312                     else:

   313                         rendered = msg

   314                     rendered = ' '*self.indent + rendered

   315                 if hasattr(consumer, 'write'):

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

   317                 else:

   318                     consumer(rendered)

   319 

   320     def start_progress(self, msg):

   321         assert not self.in_progress, (

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

   323             % (msg, self.in_progress))

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

   325             sys.stdout.write(msg)

   326             sys.stdout.flush()

   327             self.in_progress_hanging = True

   328         else:

   329             self.in_progress_hanging = False

   330         self.in_progress = msg

   331 

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

   333         assert self.in_progress, (

   334             "Tried to end_progress without start_progress")

   335         if self.stdout_level_matches(self.NOTIFY):

   336             if not self.in_progress_hanging:

   337                 # Some message has been printed out since start_progress

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

   339                 sys.stdout.flush()

   340             else:

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

   342                 sys.stdout.flush()

   343         self.in_progress = None

   344         self.in_progress_hanging = False

   345 

   346     def show_progress(self):

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

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

   349         if self.in_progress_hanging:

   350             sys.stdout.write('.')

   351             sys.stdout.flush()

   352 

   353     def stdout_level_matches(self, level):

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

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

   356 

   357     def _stdout_level(self):

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

   359         for level, consumer in self.consumers:

   360             if consumer is sys.stdout:

   361                 return level

   362         return self.FATAL

   363 

   364     def level_matches(self, level, consumer_level):

   365         """

   366         >>> l = Logger([])

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

   368         False

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

   370         True

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

   372         False

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

   374         True

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

   376         True

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

   378         False

   379         """

   380         if isinstance(level, slice):

   381             start, stop = level.start, level.stop

   382             if start is not None and start > consumer_level:

   383                 return False

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

   385                 return False

   386             return True

   387         else:

   388             return level >= consumer_level

   389 

   390     #@classmethod

   391     def level_for_integer(cls, level):

   392         levels = cls.LEVELS

   393         if level < 0:

   394             return levels[0]

   395         if level >= len(levels):

   396             return levels[-1]

   397         return levels[level]

   398 

   399     level_for_integer = classmethod(level_for_integer)

   400 

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

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

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

   404 

   405 def mkdir(path):

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

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

   408         os.makedirs(path)

   409     else:

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

   411 

   412 def copyfileordir(src, dest):

   413     if os.path.isdir(src):

   414         shutil.copytree(src, dest, True)

   415     else:

   416         shutil.copy2(src, dest)

   417 

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

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

   420         # Some bad symlink in the src

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

   422         return

   423     if os.path.exists(dest):

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

   425         return

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

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

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

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

   430         srcpath = os.path.abspath(src)

   431     else:

   432         srcpath = os.readlink(src)

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

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

   435         try:

   436             os.symlink(srcpath, dest)

   437         except (OSError, NotImplementedError):

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

   439             copyfileordir(src, dest)

   440     else:

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

   442         copyfileordir(src, dest)

   443 

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

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

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

   447         f = open(dest, 'wb')

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

   449         f.close()

   450         return

   451     else:

   452         f = open(dest, 'rb')

   453         c = f.read()

   454         f.close()

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

   456             if not overwrite:

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

   458                 return

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

   460             f = open(dest, 'wb')

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

   462             f.close()

   463         else:

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

   465 

   466 def rmtree(dir):

   467     if os.path.exists(dir):

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

   469         shutil.rmtree(dir)

   470     else:

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

   472 

   473 def make_exe(fn):

   474     if hasattr(os, 'chmod'):

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

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

   477         os.chmod(fn, newmode)

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

   479 

   480 def _find_file(filename, dirs):

   481     for dir in reversed(dirs):

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

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

   484             return True, files[0]

   485     return False, filename

   486 

   487 def _install_req(py_executable, unzip=False, distribute=False,

   488                  search_dirs=None, never_download=False):

   489 

   490     if search_dirs is None:

   491         search_dirs = file_search_dirs()

   492 

   493     if not distribute:

   494         egg_path = 'setuptools-*-py%s.egg' % sys.version[:3]

   495         found, egg_path = _find_file(egg_path, search_dirs)

   496         project_name = 'setuptools'

   497         bootstrap_script = EZ_SETUP_PY

   498         tgz_path = None

   499     else:

   500         # Look for a distribute egg (these are not distributed by default,

   501         # but can be made available by the user)

   502         egg_path = 'distribute-*-py%s.egg' % sys.version[:3]

   503         found, egg_path = _find_file(egg_path, search_dirs)

   504         project_name = 'distribute'

   505         if found:

   506             tgz_path = None

   507             bootstrap_script = DISTRIBUTE_FROM_EGG_PY

   508         else:

   509             # Fall back to sdist

   510             # NB: egg_path is not None iff tgz_path is None

   511             # iff bootstrap_script is a generic setup script accepting

   512             # the standard arguments.

   513             egg_path = None

   514             tgz_path = 'distribute-*.tar.gz'

   515             found, tgz_path = _find_file(tgz_path, search_dirs)

   516             bootstrap_script = DISTRIBUTE_SETUP_PY

   517 

   518     if is_jython and os._name == 'nt':

   519         # Jython's .bat sys.executable can't handle a command line

   520         # argument with newlines

   521         fd, ez_setup = tempfile.mkstemp('.py')

   522         os.write(fd, bootstrap_script)

   523         os.close(fd)

   524         cmd = [py_executable, ez_setup]

   525     else:

   526         cmd = [py_executable, '-c', bootstrap_script]

   527     if unzip and egg_path:

   528         cmd.append('--always-unzip')

   529     env = {}

   530     remove_from_env = ['__PYVENV_LAUNCHER__']

   531     if logger.stdout_level_matches(logger.DEBUG) and egg_path:

   532         cmd.append('-v')

   533 

   534     old_chdir = os.getcwd()

   535     if egg_path is not None and os.path.exists(egg_path):

   536         logger.info('Using existing %s egg: %s' % (project_name, egg_path))

   537         cmd.append(egg_path)

   538         if os.environ.get('PYTHONPATH'):

   539             env['PYTHONPATH'] = egg_path + os.path.pathsep + os.environ['PYTHONPATH']

   540         else:

   541             env['PYTHONPATH'] = egg_path

   542     elif tgz_path is not None and os.path.exists(tgz_path):

   543         # Found a tgz source dist, let's chdir

   544         logger.info('Using existing %s egg: %s' % (project_name, tgz_path))

   545         os.chdir(os.path.dirname(tgz_path))

   546         # in this case, we want to be sure that PYTHONPATH is unset (not

   547         # just empty, really unset), else CPython tries to import the

   548         # site.py that it's in virtualenv_support

   549         remove_from_env.append('PYTHONPATH')

   550     elif never_download:

   551         logger.fatal("Can't find any local distributions of %s to install "

   552                      "and --never-download is set.  Either re-run virtualenv "

   553                      "without the --never-download option, or place a %s "

   554                      "distribution (%s) in one of these "

   555                      "locations: %r" % (project_name, project_name,

   556                                         egg_path or tgz_path,

   557                                         search_dirs))

   558         sys.exit(1)

   559     elif egg_path:

   560         logger.info('No %s egg found; downloading' % project_name)

   561         cmd.extend(['--always-copy', '-U', project_name])

   562     else:

   563         logger.info('No %s tgz found; downloading' % project_name)

   564     logger.start_progress('Installing %s...' % project_name)

   565     logger.indent += 2

   566     cwd = None

   567     if project_name == 'distribute':

   568         env['DONT_PATCH_SETUPTOOLS'] = 'true'

   569 

   570     def _filter_ez_setup(line):

   571         return filter_ez_setup(line, project_name)

   572 

   573     if not os.access(os.getcwd(), os.W_OK):

   574         cwd = tempfile.mkdtemp()

   575         if tgz_path is not None and os.path.exists(tgz_path):

   576             # the current working dir is hostile, let's copy the

   577             # tarball to a temp dir

   578             target = os.path.join(cwd, os.path.split(tgz_path)[-1])

   579             shutil.copy(tgz_path, target)

   580     try:

   581         call_subprocess(cmd, show_stdout=False,

   582                         filter_stdout=_filter_ez_setup,

   583                         extra_env=env,

   584                         remove_from_env=remove_from_env,

   585                         cwd=cwd)

   586     finally:

   587         logger.indent -= 2

   588         logger.end_progress()

   589         if cwd is not None:

   590             shutil.rmtree(cwd)

   591         if os.getcwd() != old_chdir:

   592             os.chdir(old_chdir)

   593         if is_jython and os._name == 'nt':

   594             os.remove(ez_setup)

   595 

   596 def file_search_dirs():

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

   598     dirs = ['.', here,

   599             join(here, 'virtualenv_support')]

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

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

   602         try:

   603             import virtualenv

   604         except ImportError:

   605             pass

   606         else:

   607             dirs.append(os.path.join(os.path.dirname(virtualenv.__file__), 'virtualenv_support'))

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

   609 

   610 def install_setuptools(py_executable, unzip=False,

   611                        search_dirs=None, never_download=False):

   612     _install_req(py_executable, unzip,

   613                  search_dirs=search_dirs, never_download=never_download)

   614 

   615 def install_distribute(py_executable, unzip=False,

   616                        search_dirs=None, never_download=False):

   617     _install_req(py_executable, unzip, distribute=True,

   618                  search_dirs=search_dirs, never_download=never_download)

   619 

   620 _pip_re = re.compile(r'^pip-.*(zip|tar.gz|tar.bz2|tgz|tbz)$', re.I)

   621 def install_pip(py_executable, search_dirs=None, never_download=False):

   622     if search_dirs is None:

   623         search_dirs = file_search_dirs()

   624 

   625     filenames = []

   626     for dir in search_dirs:

   627         filenames.extend([join(dir, fn) for fn in os.listdir(dir)

   628                           if _pip_re.search(fn)])

   629     filenames = [(os.path.basename(filename).lower(), i, filename) for i, filename in enumerate(filenames)]

   630     filenames.sort()

   631     filenames = [filename for basename, i, filename in filenames]

   632     if not filenames:

   633         filename = 'pip'

   634     else:

   635         filename = filenames[-1]

   636     easy_install_script = 'easy_install'

   637     if is_win:

   638         easy_install_script = 'easy_install-script.py'

   639     # There's two subtle issues here when invoking easy_install.

   640     # 1. On unix-like systems the easy_install script can *only* be executed

   641     #    directly if its full filesystem path is no longer than 78 characters.

   642     # 2. A work around to [1] is to use the `python path/to/easy_install foo`

   643     #    pattern, but that breaks if the path contains non-ASCII characters, as

   644     #    you can't put the file encoding declaration before the shebang line.

   645     # The solution is to use Python's -x flag to skip the first line of the

   646     # script (and any ASCII decoding errors that may have occurred in that line)

   647     cmd = [py_executable, '-x', join(os.path.dirname(py_executable), easy_install_script), filename]

   648     # jython and pypy don't yet support -x

   649     if is_jython or is_pypy:

   650         cmd.remove('-x')

   651     if filename == 'pip':

   652         if never_download:

   653             logger.fatal("Can't find any local distributions of pip to install "

   654                          "and --never-download is set.  Either re-run virtualenv "

   655                          "without the --never-download option, or place a pip "

   656                          "source distribution (zip/tar.gz/tar.bz2) in one of these "

   657                          "locations: %r" % search_dirs)

   658             sys.exit(1)

   659         logger.info('Installing pip from network...')

   660     else:

   661         logger.info('Installing existing %s distribution: %s' % (

   662                 os.path.basename(filename), filename))

   663     logger.start_progress('Installing pip...')

   664     logger.indent += 2

   665     def _filter_setup(line):

   666         return filter_ez_setup(line, 'pip')

   667     try:

   668         call_subprocess(cmd, show_stdout=False,

   669                         filter_stdout=_filter_setup)

   670     finally:

   671         logger.indent -= 2

   672         logger.end_progress()

   673 

   674 def filter_ez_setup(line, project_name='setuptools'):

   675     if not line.strip():

   676         return Logger.DEBUG

   677     if project_name == 'distribute':

   678         for prefix in ('Extracting', 'Now working', 'Installing', 'Before',

   679                        'Scanning', 'Setuptools', 'Egg', 'Already',

   680                        'running', 'writing', 'reading', 'installing',

   681                        'creating', 'copying', 'byte-compiling', 'removing',

   682                        'Processing'):

   683             if line.startswith(prefix):

   684                 return Logger.DEBUG

   685         return Logger.DEBUG

   686     for prefix in ['Reading ', 'Best match', 'Processing setuptools',

   687                    'Copying setuptools', 'Adding setuptools',

   688                    'Installing ', 'Installed ']:

   689         if line.startswith(prefix):

   690             return Logger.DEBUG

   691     return Logger.INFO

   692 

   693 

   694 class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):

   695     """

   696     Custom help formatter for use in ConfigOptionParser that updates

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

   698     in the help listing

   699     """

   700     def expand_default(self, option):

   701         if self.parser is not None:

   702             self.parser.update_defaults(self.parser.defaults)

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

   704 

   705 

   706 class ConfigOptionParser(optparse.OptionParser):

   707     """

   708     Custom option parser which updates its defaults by by checking the

   709     configuration files and environmental variables

   710     """

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

   712         self.config = ConfigParser.RawConfigParser()

   713         self.files = self.get_config_files()

   714         self.config.read(self.files)

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

   716 

   717     def get_config_files(self):

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

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

   720             return [config_file]

   721         return [default_config_file]

   722 

   723     def update_defaults(self, defaults):

   724         """

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

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

   727         options (lists).

   728         """

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

   730         config = {}

   731         # 1. config files

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

   733         # 2. environmental variables

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

   735         # Then set the options with those values

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

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

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

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

   740             option = self.get_option(key)

   741             if option is not None:

   742                 # ignore empty values

   743                 if not val:

   744                     continue

   745                 # handle multiline configs

   746                 if option.action == 'append':

   747                     val = val.split()

   748                 else:

   749                     option.nargs = 1

   750                 if option.action == 'store_false':

   751                     val = not strtobool(val)

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

   753                     val = strtobool(val)

   754                 try:

   755                     val = option.convert_value(key, val)

   756                 except optparse.OptionValueError:

   757                     e = sys.exc_info()[1]

   758                     print("An error occured during configuration: %s" % e)

   759                     sys.exit(3)

   760                 defaults[option.dest] = val

   761         return defaults

   762 

   763     def get_config_section(self, name):

   764         """

   765         Get a section of a configuration

   766         """

   767         if self.config.has_section(name):

   768             return self.config.items(name)

   769         return []

   770 

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

   772         """

   773         Returns a generator with all environmental vars with prefix VIRTUALENV

   774         """

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

   776             if key.startswith(prefix):

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

   778 

   779     def get_default_values(self):

   780         """

   781         Overridding to make updating the defaults after instantiation of

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

   783         """

   784         if not self.process_default_values:

   785             # Old, pre-Optik 1.5 behaviour.

   786             return optparse.Values(self.defaults)

   787 

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

   789         for option in self._get_all_options():

   790             default = defaults.get(option.dest)

   791             if isinstance(default, basestring):

   792                 opt_str = option.get_opt_string()

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

   794         return optparse.Values(defaults)

   795 

   796 

   797 def main():

   798     parser = ConfigOptionParser(

   799         version=virtualenv_version,

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

   801         formatter=UpdatingDefaultsHelpFormatter())

   802 

   803     parser.add_option(

   804         '-v', '--verbose',

   805         action='count',

   806         dest='verbose',

   807         default=0,

   808         help="Increase verbosity")

   809 

   810     parser.add_option(

   811         '-q', '--quiet',

   812         action='count',

   813         dest='quiet',

   814         default=0,

   815         help='Decrease verbosity')

   816 

   817     parser.add_option(

   818         '-p', '--python',

   819         dest='python',

   820         metavar='PYTHON_EXE',

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

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

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

   824 

   825     parser.add_option(

   826         '--clear',

   827         dest='clear',

   828         action='store_true',

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

   830 

   831     parser.set_defaults(system_site_packages=False)

   832     parser.add_option(

   833         '--no-site-packages',

   834         dest='system_site_packages',

   835         action='store_false',

   836         help="Don't give access to the global site-packages dir to the "

   837              "virtual environment (default)")

   838 

   839     parser.add_option(

   840         '--system-site-packages',

   841         dest='system_site_packages',

   842         action='store_true',

   843         help="Give access to the global site-packages dir to the "

   844              "virtual environment")

   845 

   846     parser.add_option(

   847         '--unzip-setuptools',

   848         dest='unzip_setuptools',

   849         action='store_true',

   850         help="Unzip Setuptools or Distribute when installing it")

   851 

   852     parser.add_option(

   853         '--relocatable',

   854         dest='relocatable',

   855         action='store_true',

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

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

   858 

   859     parser.add_option(

   860         '--distribute', '--use-distribute',  # the second option is for legacy reasons here. Hi Kenneth!

   861         dest='use_distribute',

   862         action='store_true',

   863         help='Use Distribute instead of Setuptools. Set environ variable '

   864         'VIRTUALENV_DISTRIBUTE to make it the default ')

   865 

   866     parser.add_option(

   867         '--setuptools',

   868         dest='use_distribute',

   869         action='store_false',

   870         help='Use Setuptools instead of Distribute.  Set environ variable '

   871         'VIRTUALENV_SETUPTOOLS to make it the default ')

   872 

   873     # Set this to True to use distribute by default, even in Python 2.

   874     parser.set_defaults(use_distribute=False)

   875 

   876     default_search_dirs = file_search_dirs()

   877     parser.add_option(

   878         '--extra-search-dir',

   879         dest="search_dirs",

   880         action="append",

   881         default=default_search_dirs,

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

   883         "You can add any number of additional --extra-search-dir paths.")

   884 

   885     parser.add_option(

   886         '--never-download',

   887         dest="never_download",

   888         action="store_true",

   889         help="Never download anything from the network.  Instead, virtualenv will fail "

   890         "if local distributions of setuptools/distribute/pip are not present.")

   891 

   892     parser.add_option(

   893         '--prompt',

   894         dest='prompt',

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

   896 

   897     if 'extend_parser' in globals():

   898         extend_parser(parser)

   899 

   900     options, args = parser.parse_args()

   901 

   902     global logger

   903 

   904     if 'adjust_options' in globals():

   905         adjust_options(options, args)

   906 

   907     verbosity = options.verbose - options.quiet

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

   909 

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

   911         env = os.environ.copy()

   912         interpreter = resolve_interpreter(options.python)

   913         if interpreter == sys.executable:

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

   915         else:

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

   917             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   918             file = __file__

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

   920                 file = file[:-1]

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

   922             raise SystemExit(popen.wait())

   923 

   924     # Force --distribute on Python 3, since setuptools is not available.

   925     if majver > 2:

   926         options.use_distribute = True

   927 

   928     if os.environ.get('PYTHONDONTWRITEBYTECODE') and not options.use_distribute:

   929         print(

   930             "The PYTHONDONTWRITEBYTECODE environment variable is "

   931             "not compatible with setuptools. Either use --distribute "

   932             "or unset PYTHONDONTWRITEBYTECODE.")

   933         sys.exit(2)

   934     if not args:

   935         print('You must provide a DEST_DIR')

   936         parser.print_help()

   937         sys.exit(2)

   938     if len(args) > 1:

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

   940             ' '.join(args)))

   941         parser.print_help()

   942         sys.exit(2)

   943 

   944     home_dir = args[0]

   945 

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

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

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

   949         sys.exit(3)

   950 

   951     if 'PYTHONHOME' in os.environ:

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

   953         del os.environ['PYTHONHOME']

   954 

   955     if options.relocatable:

   956         make_environment_relocatable(home_dir)

   957         return

   958 

   959     create_environment(home_dir,

   960                        site_packages=options.system_site_packages,

   961                        clear=options.clear,

   962                        unzip_setuptools=options.unzip_setuptools,

   963                        use_distribute=options.use_distribute,

   964                        prompt=options.prompt,

   965                        search_dirs=options.search_dirs,

   966                        never_download=options.never_download)

   967     if 'after_install' in globals():

   968         after_install(options, home_dir)

   969 

   970 def call_subprocess(cmd, show_stdout=True,

   971                     filter_stdout=None, cwd=None,

   972                     raise_on_returncode=True, extra_env=None,

   973                     remove_from_env=None):

   974     cmd_parts = []

   975     for part in cmd:

   976         if len(part) > 45:

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

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

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

   980         if hasattr(part, 'decode'):

   981             try:

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

   983             except UnicodeDecodeError:

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

   985         cmd_parts.append(part)

   986     cmd_desc = ' '.join(cmd_parts)

   987     if show_stdout:

   988         stdout = None

   989     else:

   990         stdout = subprocess.PIPE

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

   992     if extra_env or remove_from_env:

   993         env = os.environ.copy()

   994         if extra_env:

   995             env.update(extra_env)

   996         if remove_from_env:

   997             for varname in remove_from_env:

   998                 env.pop(varname, None)

   999     else:

  1000         env = None

  1001     try:

  1002         proc = subprocess.Popen(

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

  1004             cwd=cwd, env=env)

  1005     except Exception:

  1006         e = sys.exc_info()[1]

  1007         logger.fatal(

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

  1009         raise

  1010     all_output = []

  1011     if stdout is not None:

  1012         stdout = proc.stdout

  1013         encoding = sys.getdefaultencoding()

  1014         fs_encoding = sys.getfilesystemencoding()

  1015         while 1:

  1016             line = stdout.readline()

  1017             try:

  1018                 line = line.decode(encoding)

  1019             except UnicodeDecodeError:

  1020                 line = line.decode(fs_encoding)

  1021             if not line:

  1022                 break

  1023             line = line.rstrip()

  1024             all_output.append(line)

  1025             if filter_stdout:

  1026                 level = filter_stdout(line)

  1027                 if isinstance(level, tuple):

  1028                     level, line = level

  1029                 logger.log(level, line)

  1030                 if not logger.stdout_level_matches(level):

  1031                     logger.show_progress()

  1032             else:

  1033                 logger.info(line)

  1034     else:

  1035         proc.communicate()

  1036     proc.wait()

  1037     if proc.returncode:

  1038         if raise_on_returncode:

  1039             if all_output:

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

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

  1042             raise OSError(

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

  1044                 % (cmd_desc, proc.returncode))

  1045         else:

  1046             logger.warn(

  1047                 "Command %s had error code %s"

  1048                 % (cmd_desc, proc.returncode))

  1049 

  1050 

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

  1052                        unzip_setuptools=False, use_distribute=False,

  1053                        prompt=None, search_dirs=None, never_download=False):

  1054     """

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

  1056 

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

  1058     directory will be on the path.

  1059 

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

  1061     first be cleared.

  1062     """

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

  1064 

  1065     py_executable = os.path.abspath(install_python(

  1066         home_dir, lib_dir, inc_dir, bin_dir,

  1067         site_packages=site_packages, clear=clear))

  1068 

  1069     install_distutils(home_dir)

  1070 

  1071     if use_distribute:

  1072         install_distribute(py_executable, unzip=unzip_setuptools,

  1073                            search_dirs=search_dirs, never_download=never_download)

  1074     else:

  1075         install_setuptools(py_executable, unzip=unzip_setuptools,

  1076                            search_dirs=search_dirs, never_download=never_download)

  1077 

  1078     install_pip(py_executable, search_dirs=search_dirs, never_download=never_download)

  1079 

  1080     install_activate(home_dir, bin_dir, prompt)

  1081 

  1082 def is_executable_file(fpath):

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

  1084 

  1085 def path_locations(home_dir):

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

  1087     where scripts go, etc)"""

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

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

  1090     if is_win:

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

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

  1093         # format):

  1094         mkdir(home_dir)

  1095         if ' ' in home_dir:

  1096             import ctypes

  1097             GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW

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

  1099             buf = ctypes.create_unicode_buffer(size)

  1100             try:

  1101                 u = unicode

  1102             except NameError:

  1103                 u = str

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

  1105             if not ret:

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

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

  1108                 print('Exiting.')

  1109                 sys.exit(3)

  1110             home_dir = str(buf.value)

  1111         lib_dir = join(home_dir, 'Lib')

  1112         inc_dir = join(home_dir, 'Include')

  1113         bin_dir = join(home_dir, 'Scripts')

  1114     if is_jython:

  1115         lib_dir = join(home_dir, 'Lib')

  1116         inc_dir = join(home_dir, 'Include')

  1117         bin_dir = join(home_dir, 'bin')

  1118     elif is_pypy:

  1119         lib_dir = home_dir

  1120         inc_dir = join(home_dir, 'include')

  1121         bin_dir = join(home_dir, 'bin')

  1122     elif not is_win:

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

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

  1125         if is_executable_file(multiarch_exec):

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

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

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

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

  1130             stdout, stderr = p.communicate()

  1131             # stdout.strip is needed to remove newline character

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

  1133         else:

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

  1135         bin_dir = join(home_dir, 'bin')