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.9.1"  # 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         '--no-setuptools',

   868         dest='no_setuptools',

   869         action='store_true',

   870         help='Do not install distribute/setuptools (or pip) '

   871         'in the new virtualenv.')

   872 

   873     parser.add_option(

   874         '--no-pip',

   875         dest='no_pip',

   876         action='store_true',

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

   878 

   879     parser.add_option(

   880         '--setuptools',

   881         dest='use_distribute',

   882         action='store_false',

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

   884         'VIRTUALENV_SETUPTOOLS to make it the default ')

   885 

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

   887     parser.set_defaults(use_distribute=False)

   888 

   889     default_search_dirs = file_search_dirs()

   890     parser.add_option(

   891         '--extra-search-dir',

   892         dest="search_dirs",

   893         action="append",

   894         default=default_search_dirs,

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

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

   897 

   898     parser.add_option(

   899         '--never-download',

   900         dest="never_download",

   901         action="store_true",

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

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

   904 

   905     parser.add_option(

   906         '--prompt',

   907         dest='prompt',

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

   909 

   910     if 'extend_parser' in globals():

   911         extend_parser(parser)

   912 

   913     options, args = parser.parse_args()

   914 

   915     global logger

   916 

   917     if 'adjust_options' in globals():

   918         adjust_options(options, args)

   919 

   920     verbosity = options.verbose - options.quiet

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

   922 

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

   924         env = os.environ.copy()

   925         interpreter = resolve_interpreter(options.python)

   926         if interpreter == sys.executable:

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

   928         else:

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

   930             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   931             file = __file__

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

   933                 file = file[:-1]

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

   935             raise SystemExit(popen.wait())

   936 

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

   938     if majver > 2:

   939         options.use_distribute = True

   940 

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

   942         print(

   943             "The PYTHONDONTWRITEBYTECODE environment variable is "

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

   945             "or unset PYTHONDONTWRITEBYTECODE.")

   946         sys.exit(2)

   947     if not args:

   948         print('You must provide a DEST_DIR')

   949         parser.print_help()

   950         sys.exit(2)

   951     if len(args) > 1:

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

   953             ' '.join(args)))

   954         parser.print_help()

   955         sys.exit(2)

   956 

   957     home_dir = args[0]

   958 

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

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

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

   962         sys.exit(3)

   963 

   964     if 'PYTHONHOME' in os.environ:

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

   966         del os.environ['PYTHONHOME']

   967 

   968     if options.relocatable:

   969         make_environment_relocatable(home_dir)

   970         return

   971 

   972     create_environment(home_dir,

   973                        site_packages=options.system_site_packages,

   974                        clear=options.clear,

   975                        unzip_setuptools=options.unzip_setuptools,

   976                        use_distribute=options.use_distribute,

   977                        prompt=options.prompt,

   978                        search_dirs=options.search_dirs,

   979                        never_download=options.never_download,

   980                        no_setuptools=options.no_setuptools,

   981                        no_pip=options.no_pip)

   982     if 'after_install' in globals():

   983         after_install(options, home_dir)

   984 

   985 def call_subprocess(cmd, show_stdout=True,

   986                     filter_stdout=None, cwd=None,

   987                     raise_on_returncode=True, extra_env=None,

   988                     remove_from_env=None):

   989     cmd_parts = []

   990     for part in cmd:

   991         if len(part) > 45:

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

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

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

   995         if hasattr(part, 'decode'):

   996             try:

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

   998             except UnicodeDecodeError:

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

  1000         cmd_parts.append(part)

  1001     cmd_desc = ' '.join(cmd_parts)

  1002     if show_stdout:

  1003         stdout = None

  1004     else:

  1005         stdout = subprocess.PIPE

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

  1007     if extra_env or remove_from_env:

  1008         env = os.environ.copy()

  1009         if extra_env:

  1010             env.update(extra_env)

  1011         if remove_from_env:

  1012             for varname in remove_from_env:

  1013                 env.pop(varname, None)

  1014     else:

  1015         env = None

  1016     try:

  1017         proc = subprocess.Popen(

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

  1019             cwd=cwd, env=env)

  1020     except Exception:

  1021         e = sys.exc_info()[1]

  1022         logger.fatal(

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

  1024         raise

  1025     all_output = []

  1026     if stdout is not None:

  1027         stdout = proc.stdout

  1028         encoding = sys.getdefaultencoding()

  1029         fs_encoding = sys.getfilesystemencoding()

  1030         while 1:

  1031             line = stdout.readline()

  1032             try:

  1033                 line = line.decode(encoding)

  1034             except UnicodeDecodeError:

  1035                 line = line.decode(fs_encoding)

  1036             if not line:

  1037                 break

  1038             line = line.rstrip()

  1039             all_output.append(line)

  1040             if filter_stdout:

  1041                 level = filter_stdout(line)

  1042                 if isinstance(level, tuple):

  1043                     level, line = level

  1044                 logger.log(level, line)

  1045                 if not logger.stdout_level_matches(level):

  1046                     logger.show_progress()

  1047             else:

  1048                 logger.info(line)

  1049     else:

  1050         proc.communicate()

  1051     proc.wait()

  1052     if proc.returncode:

  1053         if raise_on_returncode:

  1054             if all_output:

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

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

  1057             raise OSError(

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

  1059                 % (cmd_desc, proc.returncode))

  1060         else:

  1061             logger.warn(

  1062                 "Command %s had error code %s"

  1063                 % (cmd_desc, proc.returncode))

  1064 

  1065 

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

  1067                        unzip_setuptools=False, use_distribute=False,

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

  1069                        no_setuptools=False, no_pip=False):

  1070     """

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

  1072 

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

  1074     directory will be on the path.

  1075 

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

  1077     first be cleared.

  1078     """

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

  1080 

  1081     py_executable = os.path.abspath(install_python(

  1082         home_dir, lib_dir, inc_dir, bin_dir,

  1083         site_packages=site_packages, clear=clear))

  1084 

  1085     install_distutils(home_dir)

  1086 

  1087     if not no_setuptools:

  1088         if use_distribute:

  1089             install_distribute(py_executable, unzip=unzip_setuptools,

  1090                                search_dirs=search_dirs, never_download=never_download)

  1091         else:

  1092             install_setuptools(py_executable, unzip=unzip_setuptools,

  1093                                search_dirs=search_dirs, never_download=never_download)

  1094 

  1095         if not no_pip:

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

  1097 

  1098     install_activate(home_dir, bin_dir, prompt)

  1099 

  1100 def is_executable_file(fpath):

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

  1102 

  1103 def path_locations(home_dir):

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

  1105     where scripts go, etc)"""

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

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

  1108     if is_win:

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

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

  1111         # format):

  1112         mkdir(home_dir)

  1113         if ' ' in home_dir:

  1114             import ctypes

  1115             GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW

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

  1117             buf = ctypes.create_unicode_buffer(size)

  1118             try:

  1119                 u = unicode

  1120             except NameError:

  1121                 u = str

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

  1123             if not ret:

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

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

  1126                 print('Exiting.')

  1127                 sys.exit(3)

  1128             home_dir = str(buf.value)

  1129         lib_dir = join(home_dir, 'Lib')

  1130         inc_dir = join(home_dir, 'Include')

  1131         bin_dir = join(home_dir, 'Scripts')

  1132     if is_jython:

  1133         lib_dir = join(home_dir, 'Lib')

  1134         inc_dir = join(home_dir, 'Include')

  1135         bin_dir = join(home_dir, 'bin')