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 virtualenv_version = "1.7.1.2"

     8 

     9 import base64

    10 import sys

    11 import os

    12 import optparse

    13 import re

    14 import shutil

    15 import logging

    16 import tempfile

    17 import zlib

    18 import errno

    19 import distutils.sysconfig

    20 from distutils.util import strtobool

    21 

    22 try:

    23     import subprocess

    24 except ImportError:

    25     if sys.version_info <= (2, 3):

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

    27         print('ERROR: this script requires Python 2.4 or greater; or at least the subprocess module.')

    28         print('If you copy subprocess.py from a newer version of Python this script will probably work')

    29         sys.exit(101)

    30     else:

    31         raise

    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 abiflags = getattr(sys, 'abiflags', '')

    53 

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

    55 if sys.platform == 'win32':

    56     user_dir = os.environ.get('APPDATA', user_dir)  # Use %APPDATA% for roaming

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

    58 else:

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

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

    61 

    62 if is_pypy:

    63     expected_exe = 'pypy'

    64 elif is_jython:

    65     expected_exe = 'jython'

    66 else:

    67     expected_exe = 'python'

    68 

    69 

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

    71                     'fnmatch', 'locale', 'encodings', 'codecs',

    72                     'stat', 'UserDict', 'readline', 'copy_reg', 'types',

    73                     're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',

    74                     'zlib']

    75 

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

    77 

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

    79 if majver == 2:

    80     if minver >= 6:

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

    82     if minver >= 7:

    83         REQUIRED_MODULES.extend(['_weakrefset'])

    84     if minver <= 3:

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

    86 elif majver == 3:

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

    88     # for different versions.

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

    90                              '_weakrefset', 'copyreg', 'tempfile', 'random',

    91                              '__future__', 'collections', 'keyword', 'tarfile',

    92                              'shutil', 'struct', 'copy'])

    93     if minver >= 2:

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

    95     if minver == 3:

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

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

    98         # added as 3.3 development continues.

    99         REQUIRED_MODULES.extend([

   100             #"aifc",

   101             #"antigravity",

   102             #"argparse",

   103             #"ast",

   104             #"asynchat",

   105             #"asyncore",

   106             "base64",

   107             #"bdb",

   108             #"binhex",

   109             "bisect",

   110             #"calendar",

   111             #"cgi",

   112             #"cgitb",

   113             #"chunk",

   114             #"cmd",

   115             #"codeop",

   116             #"code",

   117             #"colorsys",

   118             #"_compat_pickle",

   119             #"compileall",

   120             #"concurrent",

   121             #"configparser",

   122             #"contextlib",

   123             #"cProfile",

   124             #"crypt",

   125             #"csv",

   126             #"ctypes",

   127             #"curses",

   128             #"datetime",

   129             #"dbm",

   130             #"decimal",

   131             #"difflib",

   132             #"dis",

   133             #"doctest",

   134             #"dummy_threading",

   135             "_dummy_thread",

   136             #"email",

   137             #"filecmp",

   138             #"fileinput",

   139             #"formatter",

   140             #"fractions",

   141             #"ftplib",

   142             #"functools",

   143             #"getopt",

   144             #"getpass",

   145             #"gettext",

   146             #"glob",

   147             #"gzip",

   148             "hashlib",

   149             "heapq",

   150             "hmac",

   151             #"html",

   152             #"http",

   153             #"idlelib",

   154             #"imaplib",

   155             #"imghdr",

   156             #"importlib",

   157             #"inspect",

   158             #"json",

   159             #"lib2to3",

   160             #"logging",

   161             #"macpath",

   162             #"macurl2path",

   163             #"mailbox",

   164             #"mailcap",

   165             #"_markupbase",

   166             #"mimetypes",

   167             #"modulefinder",

   168             #"multiprocessing",

   169             #"netrc",

   170             #"nntplib",

   171             #"nturl2path",

   172             #"numbers",

   173             #"opcode",

   174             #"optparse",

   175             #"os2emxpath",

   176             #"pdb",

   177             #"pickle",

   178             #"pickletools",

   179             #"pipes",

   180             #"pkgutil",

   181             #"platform",

   182             #"plat-linux2",

   183             #"plistlib",

   184             #"poplib",

   185             #"pprint",

   186             #"profile",

   187             #"pstats",

   188             #"pty",

   189             #"pyclbr",

   190             #"py_compile",

   191             #"pydoc_data",

   192             #"pydoc",

   193             #"_pyio",

   194             #"queue",

   195             #"quopri",

   196             "reprlib",

   197             "rlcompleter",

   198             #"runpy",

   199             #"sched",

   200             #"shelve",

   201             #"shlex",

   202             #"smtpd",

   203             #"smtplib",

   204             #"sndhdr",

   205             #"socket",

   206             #"socketserver",

   207             #"sqlite3",

   208             #"ssl",

   209             #"stringprep",

   210             #"string",

   211             #"_strptime",

   212             #"subprocess",

   213             #"sunau",

   214             #"symbol",

   215             #"symtable",

   216             #"sysconfig",

   217             #"tabnanny",

   218             #"telnetlib",

   219             #"test",

   220             #"textwrap",

   221             #"this",

   222             #"_threading_local",

   223             #"threading",

   224             #"timeit",

   225             #"tkinter",

   226             #"tokenize",

   227             #"token",

   228             #"traceback",

   229             #"trace",

   230             #"tty",

   231             #"turtledemo",

   232             #"turtle",

   233             #"unittest",

   234             #"urllib",

   235             #"uuid",

   236             #"uu",

   237             #"wave",

   238             "weakref",

   239             #"webbrowser",

   240             #"wsgiref",

   241             #"xdrlib",

   242             #"xml",

   243             #"xmlrpc",

   244             #"zipfile",

   245         ])

   246 

   247 if is_pypy:

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

   249     # during the bootstrap

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

   251 

   252 class Logger(object):

   253 

   254     """

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

   256     levels, to avoid some redundancy of displayed information.

   257     """

   258 

   259     DEBUG = logging.DEBUG

   260     INFO = logging.INFO

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

   262     WARN = WARNING = logging.WARN

   263     ERROR = logging.ERROR

   264     FATAL = logging.FATAL

   265 

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

   267 

   268     def __init__(self, consumers):

   269         self.consumers = consumers

   270         self.indent = 0

   271         self.in_progress = None

   272         self.in_progress_hanging = False

   273 

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

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

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

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

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

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

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

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

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

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

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

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

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

   287         if args:

   288             if kw:

   289                 raise TypeError(

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

   291         args = args or kw

   292         rendered = None

   293         for consumer_level, consumer in self.consumers:

   294             if self.level_matches(level, consumer_level):

   295                 if (self.in_progress_hanging

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

   297                     self.in_progress_hanging = False

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

   299                     sys.stdout.flush()

   300                 if rendered is None:

   301                     if args:

   302                         rendered = msg % args

   303                     else:

   304                         rendered = msg

   305                     rendered = ' '*self.indent + rendered

   306                 if hasattr(consumer, 'write'):

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

   308                 else:

   309                     consumer(rendered)

   310 

   311     def start_progress(self, msg):

   312         assert not self.in_progress, (

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

   314             % (msg, self.in_progress))

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

   316             sys.stdout.write(msg)

   317             sys.stdout.flush()

   318             self.in_progress_hanging = True

   319         else:

   320             self.in_progress_hanging = False

   321         self.in_progress = msg

   322 

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

   324         assert self.in_progress, (

   325             "Tried to end_progress without start_progress")

   326         if self.stdout_level_matches(self.NOTIFY):

   327             if not self.in_progress_hanging:

   328                 # Some message has been printed out since start_progress

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

   330                 sys.stdout.flush()

   331             else:

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

   333                 sys.stdout.flush()

   334         self.in_progress = None

   335         self.in_progress_hanging = False

   336 

   337     def show_progress(self):

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

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

   340         if self.in_progress_hanging:

   341             sys.stdout.write('.')

   342             sys.stdout.flush()

   343 

   344     def stdout_level_matches(self, level):

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

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

   347 

   348     def _stdout_level(self):

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

   350         for level, consumer in self.consumers:

   351             if consumer is sys.stdout:

   352                 return level

   353         return self.FATAL

   354 

   355     def level_matches(self, level, consumer_level):

   356         """

   357         >>> l = Logger([])

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

   359         False

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

   361         True

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

   363         False

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

   365         True

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

   367         True

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

   369         False

   370         """

   371         if isinstance(level, slice):

   372             start, stop = level.start, level.stop

   373             if start is not None and start > consumer_level:

   374                 return False

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

   376                 return False

   377             return True

   378         else:

   379             return level >= consumer_level

   380 

   381     #@classmethod

   382     def level_for_integer(cls, level):

   383         levels = cls.LEVELS

   384         if level < 0:

   385             return levels[0]

   386         if level >= len(levels):

   387             return levels[-1]

   388         return levels[level]

   389 

   390     level_for_integer = classmethod(level_for_integer)

   391 

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

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

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

   395 

   396 def mkdir(path):

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

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

   399         os.makedirs(path)

   400     else:

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

   402 

   403 def copyfileordir(src, dest):

   404     if os.path.isdir(src):

   405         shutil.copytree(src, dest, True)

   406     else:

   407         shutil.copy2(src, dest)

   408 

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

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

   411         # Some bad symlink in the src

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

   413         return

   414     if os.path.exists(dest):

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

   416         return

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

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

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

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

   421         srcpath = os.path.abspath(src)

   422     else:

   423         srcpath = os.readlink(src)

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

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

   426         try:

   427             os.symlink(srcpath, dest)

   428         except (OSError, NotImplementedError):

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

   430             copyfileordir(src, dest)

   431     else:

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

   433         copyfileordir(src, dest)

   434 

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

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

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

   438         f = open(dest, 'wb')

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

   440         f.close()

   441         return

   442     else:

   443         f = open(dest, 'rb')

   444         c = f.read()

   445         f.close()

   446         if c != content:

   447             if not overwrite:

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

   449                 return

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

   451             f = open(dest, 'wb')

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

   453             f.close()

   454         else:

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

   456 

   457 def rmtree(dir):

   458     if os.path.exists(dir):

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

   460         shutil.rmtree(dir)

   461     else:

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

   463 

   464 def make_exe(fn):

   465     if hasattr(os, 'chmod'):

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

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

   468         os.chmod(fn, newmode)

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

   470 

   471 def _find_file(filename, dirs):

   472     for dir in reversed(dirs):

   473         if os.path.exists(join(dir, filename)):

   474             return join(dir, filename)

   475     return filename

   476 

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

   478                  search_dirs=None, never_download=False):

   479 

   480     if search_dirs is None:

   481         search_dirs = file_search_dirs()

   482 

   483     if not distribute:

   484         setup_fn = 'setuptools-0.6c11-py%s.egg' % sys.version[:3]

   485         project_name = 'setuptools'

   486         bootstrap_script = EZ_SETUP_PY

   487         source = None

   488     else:

   489         setup_fn = None

   490         source = 'distribute-0.6.24.tar.gz'

   491         project_name = 'distribute'

   492         bootstrap_script = DISTRIBUTE_SETUP_PY

   493 

   494     if setup_fn is not None:

   495         setup_fn = _find_file(setup_fn, search_dirs)

   496 

   497     if source is not None:

   498         source = _find_file(source, search_dirs)

   499 

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

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

   502         # argument with newlines

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

   504         os.write(fd, bootstrap_script)

   505         os.close(fd)

   506         cmd = [py_executable, ez_setup]

   507     else:

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

   509     if unzip:

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

   511     env = {}

   512     remove_from_env = []

   513     if logger.stdout_level_matches(logger.DEBUG):

   514         cmd.append('-v')

   515 

   516     old_chdir = os.getcwd()

   517     if setup_fn is not None and os.path.exists(setup_fn):

   518         logger.info('Using existing %s egg: %s' % (project_name, setup_fn))

   519         cmd.append(setup_fn)

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

   521             env['PYTHONPATH'] = setup_fn + os.path.pathsep + os.environ['PYTHONPATH']

   522         else:

   523             env['PYTHONPATH'] = setup_fn

   524     else:

   525         # the source is found, let's chdir

   526         if source is not None and os.path.exists(source):

   527             logger.info('Using existing %s egg: %s' % (project_name, source))

   528             os.chdir(os.path.dirname(source))

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

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

   531             # site.py that it's in virtualenv_support

   532             remove_from_env.append('PYTHONPATH')

   533         else:

   534             if never_download:

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

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

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

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

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

   540                                                 setup_fn or source,

   541                                                 search_dirs))

   542                 sys.exit(1)

   543 

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

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

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

   547     logger.indent += 2

   548     cwd = None

   549     if project_name == 'distribute':

   550         env['DONT_PATCH_SETUPTOOLS'] = 'true'

   551 

   552     def _filter_ez_setup(line):

   553         return filter_ez_setup(line, project_name)

   554 

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

   556         cwd = tempfile.mkdtemp()

   557         if source is not None and os.path.exists(source):

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

   559             # tarball to a temp dir

   560             target = os.path.join(cwd, os.path.split(source)[-1])

   561             shutil.copy(source, target)

   562     try:

   563         call_subprocess(cmd, show_stdout=False,

   564                         filter_stdout=_filter_ez_setup,

   565                         extra_env=env,

   566                         remove_from_env=remove_from_env,

   567                         cwd=cwd)

   568     finally:

   569         logger.indent -= 2

   570         logger.end_progress()

   571         if os.getcwd() != old_chdir:

   572             os.chdir(old_chdir)

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

   574             os.remove(ez_setup)

   575 

   576 def file_search_dirs():

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

   578     dirs = ['.', here,

   579             join(here, 'virtualenv_support')]

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

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

   582         try:

   583             import virtualenv

   584         except ImportError:

   585             pass

   586         else:

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

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

   589 

   590 def install_setuptools(py_executable, unzip=False,

   591                        search_dirs=None, never_download=False):

   592     _install_req(py_executable, unzip,

   593                  search_dirs=search_dirs, never_download=never_download)

   594 

   595 def install_distribute(py_executable, unzip=False,

   596                        search_dirs=None, never_download=False):

   597     _install_req(py_executable, unzip, distribute=True,

   598                  search_dirs=search_dirs, never_download=never_download)

   599 

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

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

   602     if search_dirs is None:

   603         search_dirs = file_search_dirs()

   604 

   605     filenames = []

   606     for dir in search_dirs:

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

   608                           if _pip_re.search(fn)])

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

   610     filenames.sort()

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

   612     if not filenames:

   613         filename = 'pip'

   614     else:

   615         filename = filenames[-1]

   616     easy_install_script = 'easy_install'

   617     if sys.platform == 'win32':

   618         easy_install_script = 'easy_install-script.py'

   619     cmd = [join(os.path.dirname(py_executable), easy_install_script), filename]

   620     if sys.platform == 'win32':

   621         cmd.insert(0, py_executable)

   622     if filename == 'pip':

   623         if never_download:

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

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

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

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

   628                          "locations: %r" % search_dirs)

   629             sys.exit(1)

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

   631     else:

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

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

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

   635     logger.indent += 2

   636     def _filter_setup(line):

   637         return filter_ez_setup(line, 'pip')

   638     try:

   639         call_subprocess(cmd, show_stdout=False,

   640                         filter_stdout=_filter_setup)

   641     finally:

   642         logger.indent -= 2

   643         logger.end_progress()

   644 

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

   646     if not line.strip():

   647         return Logger.DEBUG

   648     if project_name == 'distribute':

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

   650                        'Scanning', 'Setuptools', 'Egg', 'Already',

   651                        'running', 'writing', 'reading', 'installing',

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

   653                        'Processing'):

   654             if line.startswith(prefix):

   655                 return Logger.DEBUG

   656         return Logger.DEBUG

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

   658                    'Copying setuptools', 'Adding setuptools',

   659                    'Installing ', 'Installed ']:

   660         if line.startswith(prefix):

   661             return Logger.DEBUG

   662     return Logger.INFO

   663 

   664 

   665 class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):

   666     """

   667     Custom help formatter for use in ConfigOptionParser that updates

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

   669     in the help listing

   670     """

   671     def expand_default(self, option):

   672         if self.parser is not None:

   673             self.parser.update_defaults(self.parser.defaults)

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

   675 

   676 

   677 class ConfigOptionParser(optparse.OptionParser):

   678     """

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

   680     configuration files and environmental variables

   681     """

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

   683         self.config = ConfigParser.RawConfigParser()

   684         self.files = self.get_config_files()

   685         self.config.read(self.files)

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

   687 

   688     def get_config_files(self):

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

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

   691             return [config_file]

   692         return [default_config_file]

   693 

   694     def update_defaults(self, defaults):

   695         """

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

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

   698         options (lists).

   699         """

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

   701         config = {}

   702         # 1. config files

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

   704         # 2. environmental variables

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

   706         # Then set the options with those values

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

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

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

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

   711             option = self.get_option(key)

   712             if option is not None:

   713                 # ignore empty values

   714                 if not val:

   715                     continue

   716                 # handle multiline configs

   717                 if option.action == 'append':

   718                     val = val.split()

   719                 else:

   720                     option.nargs = 1

   721                 if option.action in ('store_true', 'store_false', 'count'):

   722                     val = strtobool(val)

   723                 try:

   724                     val = option.convert_value(key, val)

   725                 except optparse.OptionValueError:

   726                     e = sys.exc_info()[1]

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

   728                     sys.exit(3)

   729                 defaults[option.dest] = val

   730         return defaults

   731 

   732     def get_config_section(self, name):

   733         """

   734         Get a section of a configuration

   735         """

   736         if self.config.has_section(name):

   737             return self.config.items(name)

   738         return []

   739 

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

   741         """

   742         Returns a generator with all environmental vars with prefix VIRTUALENV

   743         """

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

   745             if key.startswith(prefix):

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

   747 

   748     def get_default_values(self):

   749         """

   750         Overridding to make updating the defaults after instantiation of

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

   752         """

   753         if not self.process_default_values:

   754             # Old, pre-Optik 1.5 behaviour.

   755             return optparse.Values(self.defaults)

   756 

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

   758         for option in self._get_all_options():

   759             default = defaults.get(option.dest)

   760             if isinstance(default, basestring):

   761                 opt_str = option.get_opt_string()

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

   763         return optparse.Values(defaults)

   764 

   765 

   766 def main():

   767     parser = ConfigOptionParser(

   768         version=virtualenv_version,

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

   770         formatter=UpdatingDefaultsHelpFormatter())

   771 

   772     parser.add_option(

   773         '-v', '--verbose',

   774         action='count',

   775         dest='verbose',

   776         default=0,

   777         help="Increase verbosity")

   778 

   779     parser.add_option(

   780         '-q', '--quiet',

   781         action='count',

   782         dest='quiet',

   783         default=0,

   784         help='Decrease verbosity')

   785 

   786     parser.add_option(

   787         '-p', '--python',

   788         dest='python',

   789         metavar='PYTHON_EXE',

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

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

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

   793 

   794     parser.add_option(

   795         '--clear',

   796         dest='clear',

   797         action='store_true',

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

   799 

   800     parser.add_option(

   801         '--no-site-packages',

   802         dest='no_site_packages',

   803         action='store_true',

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

   805              "virtual environment")

   806 

   807     parser.add_option(

   808         '--system-site-packages',

   809         dest='system_site_packages',

   810         action='store_true',

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

   812              "virtual environment")

   813 

   814     parser.add_option(

   815         '--unzip-setuptools',

   816         dest='unzip_setuptools',

   817         action='store_true',

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

   819 

   820     parser.add_option(

   821         '--relocatable',

   822         dest='relocatable',

   823         action='store_true',

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

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

   826 

   827     parser.add_option(

   828         '--distribute',

   829         dest='use_distribute',

   830         action='store_true',

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

   832         'VIRTUALENV_DISTRIBUTE to make it the default ')

   833 

   834     default_search_dirs = file_search_dirs()

   835     parser.add_option(

   836         '--extra-search-dir',

   837         dest="search_dirs",

   838         action="append",

   839         default=default_search_dirs,

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

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

   842 

   843     parser.add_option(

   844         '--never-download',

   845         dest="never_download",

   846         action="store_true",

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

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

   849 

   850     parser.add_option(

   851         '--prompt=',

   852         dest='prompt',

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

   854 

   855     if 'extend_parser' in globals():

   856         extend_parser(parser)

   857 

   858     options, args = parser.parse_args()

   859 

   860     global logger

   861 

   862     if 'adjust_options' in globals():

   863         adjust_options(options, args)

   864 

   865     verbosity = options.verbose - options.quiet

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

   867 

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

   869         env = os.environ.copy()

   870         interpreter = resolve_interpreter(options.python)

   871         if interpreter == sys.executable:

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

   873         else:

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

   875             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   876             file = __file__

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

   878                 file = file[:-1]

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

   880             raise SystemExit(popen.wait())

   881 

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

   883     if majver > 2:

   884         options.use_distribute = True

   885 

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

   887         print(

   888             "The PYTHONDONTWRITEBYTECODE environment variable is "

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

   890             "or unset PYTHONDONTWRITEBYTECODE.")

   891         sys.exit(2)

   892     if not args:

   893         print('You must provide a DEST_DIR')

   894         parser.print_help()

   895         sys.exit(2)

   896     if len(args) > 1:

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

   898             ' '.join(args)))

   899         parser.print_help()

   900         sys.exit(2)

   901 

   902     home_dir = args[0]

   903 

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

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

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

   907         sys.exit(3)

   908 

   909     if 'PYTHONHOME' in os.environ:

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

   911         del os.environ['PYTHONHOME']

   912 

   913     if options.relocatable:

   914         make_environment_relocatable(home_dir)

   915         return

   916 

   917     if options.no_site_packages:

   918         logger.warn('The --no-site-packages flag is deprecated; it is now '

   919                     'the default behavior.')

   920 

   921     create_environment(home_dir,

   922                        site_packages=options.system_site_packages,

   923                        clear=options.clear,

   924                        unzip_setuptools=options.unzip_setuptools,

   925                        use_distribute=options.use_distribute,

   926                        prompt=options.prompt,

   927                        search_dirs=options.search_dirs,

   928                        never_download=options.never_download)

   929     if 'after_install' in globals():

   930         after_install(options, home_dir)

   931 

   932 def call_subprocess(cmd, show_stdout=True,

   933                     filter_stdout=None, cwd=None,

   934                     raise_on_returncode=True, extra_env=None,

   935                     remove_from_env=None):

   936     cmd_parts = []

   937     for part in cmd:

   938         if len(part) > 45:

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

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

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

   942         if hasattr(part, 'decode'):

   943             try:

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

   945             except UnicodeDecodeError:

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

   947         cmd_parts.append(part)

   948     cmd_desc = ' '.join(cmd_parts)

   949     if show_stdout:

   950         stdout = None

   951     else:

   952         stdout = subprocess.PIPE

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

   954     if extra_env or remove_from_env:

   955         env = os.environ.copy()

   956         if extra_env:

   957             env.update(extra_env)

   958         if remove_from_env:

   959             for varname in remove_from_env:

   960                 env.pop(varname, None)

   961     else:

   962         env = None

   963     try:

   964         proc = subprocess.Popen(

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

   966             cwd=cwd, env=env)

   967     except Exception:

   968         e = sys.exc_info()[1]

   969         logger.fatal(

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

   971         raise

   972     all_output = []

   973     if stdout is not None:

   974         stdout = proc.stdout

   975         encoding = sys.getdefaultencoding()

   976         fs_encoding = sys.getfilesystemencoding()

   977         while 1:

   978             line = stdout.readline()

   979             try:

   980                 line = line.decode(encoding)

   981             except UnicodeDecodeError:

   982                 line = line.decode(fs_encoding)

   983             if not line:

   984                 break

   985             line = line.rstrip()

   986             all_output.append(line)

   987             if filter_stdout:

   988                 level = filter_stdout(line)

   989                 if isinstance(level, tuple):

   990                     level, line = level

   991                 logger.log(level, line)

   992                 if not logger.stdout_level_matches(level):

   993                     logger.show_progress()

   994             else:

   995                 logger.info(line)

   996     else:

   997         proc.communicate()

   998     proc.wait()

   999     if proc.returncode:

  1000         if raise_on_returncode:

  1001             if all_output:

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

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

  1004             raise OSError(

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

  1006                 % (cmd_desc, proc.returncode))

  1007         else:

  1008             logger.warn(

  1009                 "Command %s had error code %s"

  1010                 % (cmd_desc, proc.returncode))

  1011 

  1012 

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

  1014                        unzip_setuptools=False, use_distribute=False,

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

  1016     """

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

  1018 

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

  1020     directory will be on the path.

  1021 

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

  1023     first be cleared.

  1024     """

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

  1026 

  1027     py_executable = os.path.abspath(install_python(

  1028         home_dir, lib_dir, inc_dir, bin_dir,

  1029         site_packages=site_packages, clear=clear))

  1030 

  1031     install_distutils(home_dir)

  1032 

  1033     # use_distribute also is True if VIRTUALENV_DISTRIBUTE env var is set

  1034     # we also check VIRTUALENV_USE_DISTRIBUTE for backwards compatibility

  1035     if use_distribute or os.environ.get('VIRTUALENV_USE_DISTRIBUTE'):

  1036         install_distribute(py_executable, unzip=unzip_setuptools,

  1037                            search_dirs=search_dirs, never_download=never_download)

  1038     else:

  1039         install_setuptools(py_executable, unzip=unzip_setuptools,

  1040                            search_dirs=search_dirs, never_download=never_download)

  1041 

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

  1043 

  1044     install_activate(home_dir, bin_dir, prompt)

  1045 

  1046 def path_locations(home_dir):

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

  1048     where scripts go, etc)"""

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

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

  1051     if sys.platform == 'win32':

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

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

  1054         # format):

  1055         mkdir(home_dir)

  1056         if ' ' in home_dir:

  1057             try:

  1058                 import win32api

  1059             except ImportError:

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

  1061                 print('To handle these kinds of paths, the win32api module must be installed:')

  1062                 print('  http://sourceforge.net/projects/pywin32/')

  1063                 sys.exit(3)

  1064             home_dir = win32api.GetShortPathName(home_dir)

  1065         lib_dir = join(home_dir, 'Lib')

  1066         inc_dir = join(home_dir, 'Include')

  1067         bin_dir = join(home_dir, 'Scripts')

  1068     elif is_jython:

  1069         lib_dir = join(home_dir, 'Lib')

  1070         inc_dir = join(home_dir, 'Include')

  1071         bin_dir = join(home_dir, 'bin')

  1072     elif is_pypy:

  1073         lib_dir = home_dir

  1074         inc_dir = join(home_dir, 'include')

  1075         bin_dir = join(home_dir, 'bin')

  1076     else:

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

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

  1079         bin_dir = join(home_dir, 'bin')

  1080     return home_dir, lib_dir, inc_dir, bin_dir

  1081 

  1082 

  1083 def change_prefix(filename, dst_prefix):

  1084     prefixes = [sys.prefix]

  1085 

  1086     if sys.platform == "darwin":

  1087         prefixes.extend((

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

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

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

  1091 

  1092     if hasattr(sys, 'real_prefix'):

  1093         prefixes.append(sys.real_prefix)

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

  1095     filename = os.path.abspath(filename)

  1096     for src_prefix in prefixes:

  1097         if filename.startswith(src_prefix):

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

  1099             assert relpath[0] == os.sep

  1100             relpath = relpath[1:]

  1101             return join(dst_prefix, relpath)

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

  1103         (filename, prefixes)

  1104 

  1105 def copy_required_modules(dst_prefix):

  1106     import imp

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

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

  1109     # definitely get the modules from the site directory of

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

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

  1112     # incompatibility issues)

  1113     _prev_sys_path = sys.path

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

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

  1116     try:

  1117         for modname in REQUIRED_MODULES:

  1118             if modname in sys.builtin_module_names:

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

  1120                 continue

  1121             try:

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

  1123             except ImportError:

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

  1125             else:

  1126                 if f is not None:

  1127                     f.close()

  1128                 dst_filename = change_prefix(filename, dst_prefix)

  1129                 copyfile(filename, dst_filename)

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

  1131                     pyfile = filename[:-1]

  1132                     if os.path.exists(pyfile):

  1133                         copyfile(pyfile, dst_filename[:-1])

  1134     finally:

  1135         sys.path = _prev_sys_path