1 #!/usr/bin/env python

     2 """Create a "virtual" Python installation

     3 """

     4 

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

     6 # and docs/conf.py as well.

     7 __version__ = "1.9.1"  # following best practices

     8 virtualenv_version = __version__  # legacy, again

     9 

    10 import base64

    11 import sys

    12 import os

    13 import codecs

    14 import optparse

    15 import re

    16 import shutil

    17 import logging

    18 import tempfile

    19 import zlib

    20 import errno

    21 import glob

    22 import distutils.sysconfig

    23 from distutils.util import strtobool

    24 import struct

    25 import subprocess

    26 

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

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

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

    30     sys.exit(101)

    31 

    32 try:

    33     set

    34 except NameError:

    35     from sets import Set as set

    36 try:

    37     basestring

    38 except NameError:

    39     basestring = str

    40 

    41 try:

    42     import ConfigParser

    43 except ImportError:

    44     import configparser as ConfigParser

    45 

    46 join = os.path.join

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

    48 

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

    50 is_pypy = hasattr(sys, 'pypy_version_info')

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

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

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

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

    55 

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

    57 if is_win:

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

    59 else:

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

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

    62 

    63 if is_pypy:

    64     expected_exe = 'pypy'

    65 elif is_jython:

    66     expected_exe = 'jython'

    67 else:

    68     expected_exe = 'python'

    69 

    70 

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

    72                     'fnmatch', 'locale', 'encodings', 'codecs',

    73                     'stat', 'UserDict', 'readline', 'copy_reg', 'types',

    74                     're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',

    75                     'zlib']

    76 

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

    78 

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

    80 if majver == 2:

    81     if minver >= 6:

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

    83     if minver >= 7:

    84         REQUIRED_MODULES.extend(['_weakrefset'])

    85     if minver <= 3:

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

    87 elif majver == 3:

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

    89     # for different versions.

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

    91                              '_weakrefset', 'copyreg', 'tempfile', 'random',

    92                              '__future__', 'collections', 'keyword', 'tarfile',

    93                              'shutil', 'struct', 'copy', 'tokenize', 'token',

    94                              'functools', 'heapq', 'bisect', 'weakref',

    95                              'reprlib'])

    96     if minver >= 2:

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

    98     if minver == 3:

    99         import sysconfig

   100         platdir = sysconfig.get_config_var('PLATDIR')

   101         REQUIRED_FILES.append(platdir)

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

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

   104         # added as 3.3 development continues.

   105         REQUIRED_MODULES.extend([

   106             #"aifc",

   107             #"antigravity",

   108             #"argparse",

   109             #"ast",

   110             #"asynchat",

   111             #"asyncore",

   112             "base64",

   113             #"bdb",

   114             #"binhex",

   115             #"bisect",

   116             #"calendar",

   117             #"cgi",

   118             #"cgitb",

   119             #"chunk",

   120             #"cmd",

   121             #"codeop",

   122             #"code",

   123             #"colorsys",

   124             #"_compat_pickle",

   125             #"compileall",

   126             #"concurrent",

   127             #"configparser",

   128             #"contextlib",

   129             #"cProfile",

   130             #"crypt",

   131             #"csv",

   132             #"ctypes",

   133             #"curses",

   134             #"datetime",

   135             #"dbm",

   136             #"decimal",

   137             #"difflib",

   138             #"dis",

   139             #"doctest",

   140             #"dummy_threading",

   141             "_dummy_thread",

   142             #"email",

   143             #"filecmp",

   144             #"fileinput",

   145             #"formatter",

   146             #"fractions",

   147             #"ftplib",

   148             #"functools",

   149             #"getopt",

   150             #"getpass",

   151             #"gettext",

   152             #"glob",

   153             #"gzip",

   154             "hashlib",

   155             #"heapq",

   156             "hmac",

   157             #"html",

   158             #"http",

   159             #"idlelib",

   160             #"imaplib",

   161             #"imghdr",

   162             "imp",

   163             "importlib",

   164             #"inspect",

   165             #"json",

   166             #"lib2to3",

   167             #"logging",

   168             #"macpath",

   169             #"macurl2path",

   170             #"mailbox",

   171             #"mailcap",

   172             #"_markupbase",

   173             #"mimetypes",

   174             #"modulefinder",

   175             #"multiprocessing",

   176             #"netrc",

   177             #"nntplib",

   178             #"nturl2path",

   179             #"numbers",

   180             #"opcode",

   181             #"optparse",

   182             #"os2emxpath",

   183             #"pdb",

   184             #"pickle",

   185             #"pickletools",

   186             #"pipes",

   187             #"pkgutil",

   188             #"platform",

   189             #"plat-linux2",

   190             #"plistlib",

   191             #"poplib",

   192             #"pprint",

   193             #"profile",

   194             #"pstats",

   195             #"pty",

   196             #"pyclbr",

   197             #"py_compile",

   198             #"pydoc_data",

   199             #"pydoc",

   200             #"_pyio",

   201             #"queue",

   202             #"quopri",

   203             #"reprlib",

   204             "rlcompleter",

   205             #"runpy",

   206             #"sched",

   207             #"shelve",

   208             #"shlex",

   209             #"smtpd",

   210             #"smtplib",

   211             #"sndhdr",

   212             #"socket",

   213             #"socketserver",

   214             #"sqlite3",

   215             #"ssl",

   216             #"stringprep",

   217             #"string",

   218             #"_strptime",

   219             #"subprocess",

   220             #"sunau",

   221             #"symbol",

   222             #"symtable",

   223             #"sysconfig",

   224             #"tabnanny",

   225             #"telnetlib",

   226             #"test",

   227             #"textwrap",

   228             #"this",

   229             #"_threading_local",

   230             #"threading",

   231             #"timeit",

   232             #"tkinter",

   233             #"tokenize",

   234             #"token",

   235             #"traceback",

   236             #"trace",

   237             #"tty",

   238             #"turtledemo",

   239             #"turtle",

   240             #"unittest",

   241             #"urllib",

   242             #"uuid",

   243             #"uu",

   244             #"wave",

   245             #"weakref",

   246             #"webbrowser",

   247             #"wsgiref",

   248             #"xdrlib",

   249             #"xml",

   250             #"xmlrpc",

   251             #"zipfile",

   252         ])

   253 

   254 if is_pypy:

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

   256     # during the bootstrap

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

   258 

   259 class Logger(object):

   260 

   261     """

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

   263     levels, to avoid some redundancy of displayed information.

   264     """

   265 

   266     DEBUG = logging.DEBUG

   267     INFO = logging.INFO

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

   269     WARN = WARNING = logging.WARN

   270     ERROR = logging.ERROR

   271     FATAL = logging.FATAL

   272 

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

   274 

   275     def __init__(self, consumers):

   276         self.consumers = consumers

   277         self.indent = 0

   278         self.in_progress = None

   279         self.in_progress_hanging = False

   280 

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

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

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

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

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

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

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

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

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

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

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

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

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

   294         if args:

   295             if kw:

   296                 raise TypeError(

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

   298         args = args or kw

   299         rendered = None

   300         for consumer_level, consumer in self.consumers:

   301             if self.level_matches(level, consumer_level):

   302                 if (self.in_progress_hanging

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

   304                     self.in_progress_hanging = False

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

   306                     sys.stdout.flush()

   307                 if rendered is None:

   308                     if args:

   309                         rendered = msg % args

   310                     else:

   311                         rendered = msg

   312                     rendered = ' '*self.indent + rendered

   313                 if hasattr(consumer, 'write'):

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

   315                 else:

   316                     consumer(rendered)

   317 

   318     def start_progress(self, msg):

   319         assert not self.in_progress, (

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

   321             % (msg, self.in_progress))

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

   323             sys.stdout.write(msg)

   324             sys.stdout.flush()

   325             self.in_progress_hanging = True

   326         else:

   327             self.in_progress_hanging = False

   328         self.in_progress = msg

   329 

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

   331         assert self.in_progress, (

   332             "Tried to end_progress without start_progress")

   333         if self.stdout_level_matches(self.NOTIFY):

   334             if not self.in_progress_hanging:

   335                 # Some message has been printed out since start_progress

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

   337                 sys.stdout.flush()

   338             else:

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

   340                 sys.stdout.flush()

   341         self.in_progress = None

   342         self.in_progress_hanging = False

   343 

   344     def show_progress(self):

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

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

   347         if self.in_progress_hanging:

   348             sys.stdout.write('.')

   349             sys.stdout.flush()

   350 

   351     def stdout_level_matches(self, level):

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

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

   354 

   355     def _stdout_level(self):

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

   357         for level, consumer in self.consumers:

   358             if consumer is sys.stdout:

   359                 return level

   360         return self.FATAL

   361 

   362     def level_matches(self, level, consumer_level):

   363         """

   364         >>> l = Logger([])

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

   366         False

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

   368         True

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

   370         False

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

   372         True

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

   374         True

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

   376         False

   377         """

   378         if isinstance(level, slice):

   379             start, stop = level.start, level.stop

   380             if start is not None and start > consumer_level:

   381                 return False

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

   383                 return False

   384             return True

   385         else:

   386             return level >= consumer_level

   387 

   388     #@classmethod

   389     def level_for_integer(cls, level):

   390         levels = cls.LEVELS

   391         if level < 0:

   392             return levels[0]

   393         if level >= len(levels):

   394             return levels[-1]

   395         return levels[level]

   396 

   397     level_for_integer = classmethod(level_for_integer)

   398 

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

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

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

   402 

   403 def mkdir(path):

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

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

   406         os.makedirs(path)

   407     else:

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

   409 

   410 def copyfileordir(src, dest):

   411     if os.path.isdir(src):

   412         shutil.copytree(src, dest, True)

   413     else:

   414         shutil.copy2(src, dest)

   415 

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

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

   418         # Some bad symlink in the src

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

   420         return

   421     if os.path.exists(dest):

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

   423         return

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

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

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

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

   428         srcpath = os.path.abspath(src)

   429     else:

   430         srcpath = os.readlink(src)

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

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

   433         try:

   434             os.symlink(srcpath, dest)

   435         except (OSError, NotImplementedError):

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

   437             copyfileordir(src, dest)

   438     else:

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

   440         copyfileordir(src, dest)

   441 

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

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

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

   445         f = open(dest, 'wb')

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

   447         f.close()

   448         return

   449     else:

   450         f = open(dest, 'rb')

   451         c = f.read()

   452         f.close()

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

   454             if not overwrite:

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

   456                 return

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

   458             f = open(dest, 'wb')

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

   460             f.close()

   461         else:

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

   463 

   464 def rmtree(dir):

   465     if os.path.exists(dir):

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

   467         shutil.rmtree(dir)

   468     else:

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

   470 

   471 def make_exe(fn):

   472     if hasattr(os, 'chmod'):

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

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

   475         os.chmod(fn, newmode)

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

   477 

   478 def _find_file(filename, dirs):

   479     for dir in reversed(dirs):

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

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

   482             return True, files[0]

   483     return False, filename

   484 

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

   486                  search_dirs=None, never_download=False):

   487 

   488     if search_dirs is None:

   489         search_dirs = file_search_dirs()

   490 

   491     if not distribute:

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

   493         found, egg_path = _find_file(egg_path, search_dirs)

   494         project_name = 'setuptools'

   495         bootstrap_script = EZ_SETUP_PY

   496         tgz_path = None

   497     else:

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

   499         # but can be made available by the user)

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

   501         found, egg_path = _find_file(egg_path, search_dirs)

   502         project_name = 'distribute'

   503         if found:

   504             tgz_path = None

   505             bootstrap_script = DISTRIBUTE_FROM_EGG_PY

   506         else:

   507             # Fall back to sdist

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

   509             # iff bootstrap_script is a generic setup script accepting

   510             # the standard arguments.

   511             egg_path = None

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

   513             found, tgz_path = _find_file(tgz_path, search_dirs)

   514             bootstrap_script = DISTRIBUTE_SETUP_PY

   515 

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

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

   518         # argument with newlines

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

   520         os.write(fd, bootstrap_script)

   521         os.close(fd)

   522         cmd = [py_executable, ez_setup]

   523     else:

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

   525     if unzip and egg_path:

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

   527     env = {}

   528     remove_from_env = ['__PYVENV_LAUNCHER__']

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

   530         cmd.append('-v')

   531 

   532     old_chdir = os.getcwd()

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

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

   535         cmd.append(egg_path)

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

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

   538         else:

   539             env['PYTHONPATH'] = egg_path

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

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

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

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

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

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

   546         # site.py that it's in virtualenv_support

   547         remove_from_env.append('PYTHONPATH')

   548     elif never_download:

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

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

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

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

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

   554                                         egg_path or tgz_path,

   555                                         search_dirs))

   556         sys.exit(1)

   557     elif egg_path:

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

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

   560     else:

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

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

   563     logger.indent += 2

   564     cwd = None

   565     if project_name == 'distribute':

   566         env['DONT_PATCH_SETUPTOOLS'] = 'true'

   567 

   568     def _filter_ez_setup(line):

   569         return filter_ez_setup(line, project_name)

   570 

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

   572         cwd = tempfile.mkdtemp()

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

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

   575             # tarball to a temp dir

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

   577             shutil.copy(tgz_path, target)

   578     try:

   579         call_subprocess(cmd, show_stdout=False,

   580                         filter_stdout=_filter_ez_setup,

   581                         extra_env=env,

   582                         remove_from_env=remove_from_env,

   583                         cwd=cwd)

   584     finally:

   585         logger.indent -= 2

   586         logger.end_progress()

   587         if cwd is not None:

   588             shutil.rmtree(cwd)

   589         if os.getcwd() != old_chdir:

   590             os.chdir(old_chdir)

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

   592             os.remove(ez_setup)

   593 

   594 def file_search_dirs():

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

   596     dirs = ['.', here,

   597             join(here, 'virtualenv_support')]

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

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

   600         try:

   601             import virtualenv

   602         except ImportError:

   603             pass

   604         else:

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

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

   607 

   608 def install_setuptools(py_executable, unzip=False,

   609                        search_dirs=None, never_download=False):

   610     _install_req(py_executable, unzip,

   611                  search_dirs=search_dirs, never_download=never_download)

   612 

   613 def install_distribute(py_executable, unzip=False,

   614                        search_dirs=None, never_download=False):

   615     _install_req(py_executable, unzip, distribute=True,

   616                  search_dirs=search_dirs, never_download=never_download)

   617 

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

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

   620     if search_dirs is None:

   621         search_dirs = file_search_dirs()

   622 

   623     filenames = []

   624     for dir in search_dirs:

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

   626                           if _pip_re.search(fn)])

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

   628     filenames.sort()

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

   630     if not filenames:

   631         filename = 'pip'

   632     else:

   633         filename = filenames[-1]

   634     easy_install_script = 'easy_install'

   635     if is_win:

   636         easy_install_script = 'easy_install-script.py'

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

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

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

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

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

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

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

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

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

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

   647     if is_jython or is_pypy:

   648         cmd.remove('-x')

   649     if filename == 'pip':

   650         if never_download:

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

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

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

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

   655                          "locations: %r" % search_dirs)

   656             sys.exit(1)

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

   658     else:

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

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

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

   662     logger.indent += 2

   663     def _filter_setup(line):

   664         return filter_ez_setup(line, 'pip')

   665     try:

   666         call_subprocess(cmd, show_stdout=False,

   667                         filter_stdout=_filter_setup)

   668     finally:

   669         logger.indent -= 2

   670         logger.end_progress()

   671 

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

   673     if not line.strip():

   674         return Logger.DEBUG

   675     if project_name == 'distribute':

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

   677                        'Scanning', 'Setuptools', 'Egg', 'Already',

   678                        'running', 'writing', 'reading', 'installing',

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

   680                        'Processing'):

   681             if line.startswith(prefix):

   682                 return Logger.DEBUG

   683         return Logger.DEBUG

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

   685                    'Copying setuptools', 'Adding setuptools',

   686                    'Installing ', 'Installed ']:

   687         if line.startswith(prefix):

   688             return Logger.DEBUG

   689     return Logger.INFO

   690 

   691 

   692 class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):

   693     """

   694     Custom help formatter for use in ConfigOptionParser that updates

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

   696     in the help listing

   697     """

   698     def expand_default(self, option):

   699         if self.parser is not None:

   700             self.parser.update_defaults(self.parser.defaults)

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

   702 

   703 

   704 class ConfigOptionParser(optparse.OptionParser):

   705     """

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

   707     configuration files and environmental variables

   708     """

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

   710         self.config = ConfigParser.RawConfigParser()

   711         self.files = self.get_config_files()

   712         self.config.read(self.files)

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

   714 

   715     def get_config_files(self):

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

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

   718             return [config_file]

   719         return [default_config_file]

   720 

   721     def update_defaults(self, defaults):

   722         """

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

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

   725         options (lists).

   726         """

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

   728         config = {}

   729         # 1. config files

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

   731         # 2. environmental variables

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

   733         # Then set the options with those values

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

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

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

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

   738             option = self.get_option(key)

   739             if option is not None:

   740                 # ignore empty values

   741                 if not val:

   742                     continue

   743                 # handle multiline configs

   744                 if option.action == 'append':

   745                     val = val.split()

   746                 else:

   747                     option.nargs = 1

   748                 if option.action == 'store_false':

   749                     val = not strtobool(val)

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

   751                     val = strtobool(val)

   752                 try:

   753                     val = option.convert_value(key, val)

   754                 except optparse.OptionValueError:

   755                     e = sys.exc_info()[1]

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

   757                     sys.exit(3)

   758                 defaults[option.dest] = val

   759         return defaults

   760 

   761     def get_config_section(self, name):

   762         """

   763         Get a section of a configuration

   764         """

   765         if self.config.has_section(name):

   766             return self.config.items(name)

   767         return []

   768 

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

   770         """

   771         Returns a generator with all environmental vars with prefix VIRTUALENV

   772         """

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

   774             if key.startswith(prefix):

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

   776 

   777     def get_default_values(self):

   778         """

   779         Overridding to make updating the defaults after instantiation of

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

   781         """

   782         if not self.process_default_values:

   783             # Old, pre-Optik 1.5 behaviour.

   784             return optparse.Values(self.defaults)

   785 

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

   787         for option in self._get_all_options():

   788             default = defaults.get(option.dest)

   789             if isinstance(default, basestring):

   790                 opt_str = option.get_opt_string()

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

   792         return optparse.Values(defaults)

   793 

   794 

   795 def main():

   796     parser = ConfigOptionParser(

   797         version=virtualenv_version,

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

   799         formatter=UpdatingDefaultsHelpFormatter())

   800 

   801     parser.add_option(

   802         '-v', '--verbose',

   803         action='count',

   804         dest='verbose',

   805         default=0,

   806         help="Increase verbosity")

   807 

   808     parser.add_option(

   809         '-q', '--quiet',

   810         action='count',

   811         dest='quiet',

   812         default=0,

   813         help='Decrease verbosity')

   814 

   815     parser.add_option(

   816         '-p', '--python',

   817         dest='python',

   818         metavar='PYTHON_EXE',

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

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

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

   822 

   823     parser.add_option(

   824         '--clear',

   825         dest='clear',

   826         action='store_true',

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

   828 

   829     parser.set_defaults(system_site_packages=False)

   830     parser.add_option(

   831         '--no-site-packages',

   832         dest='system_site_packages',

   833         action='store_false',

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

   835              "virtual environment (default)")

   836 

   837     parser.add_option(

   838         '--system-site-packages',

   839         dest='system_site_packages',

   840         action='store_true',

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

   842              "virtual environment")

   843 

   844     parser.add_option(

   845         '--unzip-setuptools',

   846         dest='unzip_setuptools',

   847         action='store_true',

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

   849 

   850     parser.add_option(

   851         '--relocatable',

   852         dest='relocatable',

   853         action='store_true',

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

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

   856 

   857     parser.add_option(

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

   859         dest='use_distribute',

   860         action='store_true',

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

   862         'VIRTUALENV_DISTRIBUTE to make it the default ')

   863 

   864     parser.add_option(

   865         '--no-setuptools',

   866         dest='no_setuptools',

   867         action='store_true',

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

   869         'in the new virtualenv.')

   870 

   871     parser.add_option(

   872         '--no-pip',

   873         dest='no_pip',

   874         action='store_true',

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

   876 

   877     parser.add_option(

   878         '--setuptools',

   879         dest='use_distribute',

   880         action='store_false',

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

   882         'VIRTUALENV_SETUPTOOLS to make it the default ')

   883 

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

   885     parser.set_defaults(use_distribute=False)

   886 

   887     default_search_dirs = file_search_dirs()

   888     parser.add_option(

   889         '--extra-search-dir',

   890         dest="search_dirs",

   891         action="append",

   892         default=default_search_dirs,

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

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

   895 

   896     parser.add_option(

   897         '--never-download',

   898         dest="never_download",

   899         action="store_true",

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

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

   902 

   903     parser.add_option(

   904         '--prompt',

   905         dest='prompt',

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

   907 

   908     if 'extend_parser' in globals():

   909         extend_parser(parser)

   910 

   911     options, args = parser.parse_args()

   912 

   913     global logger

   914 

   915     if 'adjust_options' in globals():

   916         adjust_options(options, args)

   917 

   918     verbosity = options.verbose - options.quiet

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

   920 

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

   922         env = os.environ.copy()

   923         interpreter = resolve_interpreter(options.python)

   924         if interpreter == sys.executable:

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

   926         else:

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

   928             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   929             file = __file__

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

   931                 file = file[:-1]

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

   933             raise SystemExit(popen.wait())

   934 

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

   936     if majver > 2:

   937         options.use_distribute = True

   938 

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

   940         print(

   941             "The PYTHONDONTWRITEBYTECODE environment variable is "

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

   943             "or unset PYTHONDONTWRITEBYTECODE.")

   944         sys.exit(2)

   945     if not args:

   946         print('You must provide a DEST_DIR')

   947         parser.print_help()

   948         sys.exit(2)

   949     if len(args) > 1:

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

   951             ' '.join(args)))

   952         parser.print_help()

   953         sys.exit(2)

   954 

   955     home_dir = args[0]

   956 

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

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

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

   960         sys.exit(3)

   961 

   962     if 'PYTHONHOME' in os.environ:

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

   964         del os.environ['PYTHONHOME']

   965 

   966     if options.relocatable:

   967         make_environment_relocatable(home_dir)

   968         return

   969 

   970     create_environment(home_dir,

   971                        site_packages=options.system_site_packages,

   972                        clear=options.clear,

   973                        unzip_setuptools=options.unzip_setuptools,

   974                        use_distribute=options.use_distribute,

   975                        prompt=options.prompt,

   976                        search_dirs=options.search_dirs,

   977                        never_download=options.never_download,

   978                        no_setuptools=options.no_setuptools,

   979                        no_pip=options.no_pip)

   980     if 'after_install' in globals():

   981         after_install(options, home_dir)

   982 

   983 def call_subprocess(cmd, show_stdout=True,

   984                     filter_stdout=None, cwd=None,

   985                     raise_on_returncode=True, extra_env=None,

   986                     remove_from_env=None):

   987     cmd_parts = []

   988     for part in cmd:

   989         if len(part) > 45:

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

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

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

   993         if hasattr(part, 'decode'):

   994             try:

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

   996             except UnicodeDecodeError:

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

   998         cmd_parts.append(part)

   999     cmd_desc = ' '.join(cmd_parts)

  1000     if show_stdout:

  1001         stdout = None

  1002     else:

  1003         stdout = subprocess.PIPE

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

  1005     if extra_env or remove_from_env:

  1006         env = os.environ.copy()

  1007         if extra_env:

  1008             env.update(extra_env)

  1009         if remove_from_env:

  1010             for varname in remove_from_env:

  1011                 env.pop(varname, None)

  1012     else:

  1013         env = None

  1014     try:

  1015         proc = subprocess.Popen(

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

  1017             cwd=cwd, env=env)

  1018     except Exception:

  1019         e = sys.exc_info()[1]

  1020         logger.fatal(

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

  1022         raise

  1023     all_output = []

  1024     if stdout is not None:

  1025         stdout = proc.stdout

  1026         encoding = sys.getdefaultencoding()

  1027         fs_encoding = sys.getfilesystemencoding()

  1028         while 1:

  1029             line = stdout.readline()

  1030             try:

  1031                 line = line.decode(encoding)

  1032             except UnicodeDecodeError:

  1033                 line = line.decode(fs_encoding)

  1034             if not line:

  1035                 break

  1036             line = line.rstrip()

  1037             all_output.append(line)

  1038             if filter_stdout:

  1039                 level = filter_stdout(line)

  1040                 if isinstance(level, tuple):

  1041                     level, line = level

  1042                 logger.log(level, line)

  1043                 if not logger.stdout_level_matches(level):

  1044                     logger.show_progress()

  1045             else:

  1046                 logger.info(line)

  1047     else:

  1048         proc.communicate()

  1049     proc.wait()

  1050     if proc.returncode:

  1051         if raise_on_returncode:

  1052             if all_output:

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

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

  1055             raise OSError(

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

  1057                 % (cmd_desc, proc.returncode))

  1058         else:

  1059             logger.warn(

  1060                 "Command %s had error code %s"

  1061                 % (cmd_desc, proc.returncode))

  1062 

  1063 

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

  1065                        unzip_setuptools=False, use_distribute=False,

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

  1067                        no_setuptools=False, no_pip=False):

  1068     """

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

  1070 

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

  1072     directory will be on the path.

  1073 

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

  1075     first be cleared.

  1076     """

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

  1078 

  1079     py_executable = os.path.abspath(install_python(

  1080         home_dir, lib_dir, inc_dir, bin_dir,

  1081         site_packages=site_packages, clear=clear))

  1082 

  1083     install_distutils(home_dir)

  1084 

  1085     if not no_setuptools:

  1086         if use_distribute:

  1087             install_distribute(py_executable, unzip=unzip_setuptools,

  1088                                search_dirs=search_dirs, never_download=never_download)

  1089         else:

  1090             install_setuptools(py_executable, unzip=unzip_setuptools,

  1091                                search_dirs=search_dirs, never_download=never_download)

  1092 

  1093         if not no_pip:

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

  1095 

  1096     install_activate(home_dir, bin_dir, prompt)

  1097 

  1098 def is_executable_file(fpath):

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

  1100 

  1101 def path_locations(home_dir):

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

  1103     where scripts go, etc)"""

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

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

  1106     if is_win:

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

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

  1109         # format):

  1110         mkdir(home_dir)

  1111         if ' ' in home_dir:

  1112             import ctypes

  1113             GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW

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

  1115             buf = ctypes.create_unicode_buffer(size)

  1116             try:

  1117                 u = unicode

  1118             except NameError:

  1119                 u = str

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

  1121             if not ret:

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

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

  1124                 print('Exiting.')

  1125                 sys.exit(3)

  1126             home_dir = str(buf.value)

  1127         lib_dir = join(home_dir, 'Lib')

  1128         inc_dir = join(home_dir, 'Include')

  1129         bin_dir = join(home_dir, 'Scripts')

  1130     if is_jython:

  1131         lib_dir = join(home_dir, 'Lib')

  1132         inc_dir = join(home_dir, 'Include')

  1133         bin_dir = join(home_dir, 'bin')

  1134     elif is_pypy:

  1135         lib_dir = home_dir

  1136         inc_dir = join(home_dir, 'include')