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.8.2"  # 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         # The whole list of 3.3 modules is reproduced below - the current

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

   101         # added as 3.3 development continues.

   102         REQUIRED_MODULES.extend([

   103             #"aifc",

   104             #"antigravity",

   105             #"argparse",

   106             #"ast",

   107             #"asynchat",

   108             #"asyncore",

   109             "base64",

   110             #"bdb",

   111             #"binhex",

   112             #"bisect",

   113             #"calendar",

   114             #"cgi",

   115             #"cgitb",

   116             #"chunk",

   117             #"cmd",

   118             #"codeop",

   119             #"code",

   120             #"colorsys",

   121             #"_compat_pickle",

   122             #"compileall",

   123             #"concurrent",

   124             #"configparser",

   125             #"contextlib",

   126             #"cProfile",

   127             #"crypt",

   128             #"csv",

   129             #"ctypes",

   130             #"curses",

   131             #"datetime",

   132             #"dbm",

   133             #"decimal",

   134             #"difflib",

   135             #"dis",

   136             #"doctest",

   137             #"dummy_threading",

   138             "_dummy_thread",

   139             #"email",

   140             #"filecmp",

   141             #"fileinput",

   142             #"formatter",

   143             #"fractions",

   144             #"ftplib",

   145             #"functools",

   146             #"getopt",

   147             #"getpass",

   148             #"gettext",

   149             #"glob",

   150             #"gzip",

   151             "hashlib",

   152             #"heapq",

   153             "hmac",

   154             #"html",

   155             #"http",

   156             #"idlelib",

   157             #"imaplib",

   158             #"imghdr",

   159             #"importlib",

   160             #"inspect",

   161             #"json",

   162             #"lib2to3",

   163             #"logging",

   164             #"macpath",

   165             #"macurl2path",

   166             #"mailbox",

   167             #"mailcap",

   168             #"_markupbase",

   169             #"mimetypes",

   170             #"modulefinder",

   171             #"multiprocessing",

   172             #"netrc",

   173             #"nntplib",

   174             #"nturl2path",

   175             #"numbers",

   176             #"opcode",

   177             #"optparse",

   178             #"os2emxpath",

   179             #"pdb",

   180             #"pickle",

   181             #"pickletools",

   182             #"pipes",

   183             #"pkgutil",

   184             #"platform",

   185             #"plat-linux2",

   186             #"plistlib",

   187             #"poplib",

   188             #"pprint",

   189             #"profile",

   190             #"pstats",

   191             #"pty",

   192             #"pyclbr",

   193             #"py_compile",

   194             #"pydoc_data",

   195             #"pydoc",

   196             #"_pyio",

   197             #"queue",

   198             #"quopri",

   199             #"reprlib",

   200             "rlcompleter",

   201             #"runpy",

   202             #"sched",

   203             #"shelve",

   204             #"shlex",

   205             #"smtpd",

   206             #"smtplib",

   207             #"sndhdr",

   208             #"socket",

   209             #"socketserver",

   210             #"sqlite3",

   211             #"ssl",

   212             #"stringprep",

   213             #"string",

   214             #"_strptime",

   215             #"subprocess",

   216             #"sunau",

   217             #"symbol",

   218             #"symtable",

   219             #"sysconfig",

   220             #"tabnanny",

   221             #"telnetlib",

   222             #"test",

   223             #"textwrap",

   224             #"this",

   225             #"_threading_local",

   226             #"threading",

   227             #"timeit",

   228             #"tkinter",

   229             #"tokenize",

   230             #"token",

   231             #"traceback",

   232             #"trace",

   233             #"tty",

   234             #"turtledemo",

   235             #"turtle",

   236             #"unittest",

   237             #"urllib",

   238             #"uuid",

   239             #"uu",

   240             #"wave",

   241             #"weakref",

   242             #"webbrowser",

   243             #"wsgiref",

   244             #"xdrlib",

   245             #"xml",

   246             #"xmlrpc",

   247             #"zipfile",

   248         ])

   249 

   250 if is_pypy:

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

   252     # during the bootstrap

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

   254 

   255 class Logger(object):

   256 

   257     """

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

   259     levels, to avoid some redundancy of displayed information.

   260     """

   261 

   262     DEBUG = logging.DEBUG

   263     INFO = logging.INFO

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

   265     WARN = WARNING = logging.WARN

   266     ERROR = logging.ERROR

   267     FATAL = logging.FATAL

   268 

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

   270 

   271     def __init__(self, consumers):

   272         self.consumers = consumers

   273         self.indent = 0

   274         self.in_progress = None

   275         self.in_progress_hanging = False

   276 

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

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

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

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

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

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

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

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

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

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

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

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

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

   290         if args:

   291             if kw:

   292                 raise TypeError(

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

   294         args = args or kw

   295         rendered = None

   296         for consumer_level, consumer in self.consumers:

   297             if self.level_matches(level, consumer_level):

   298                 if (self.in_progress_hanging

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

   300                     self.in_progress_hanging = False

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

   302                     sys.stdout.flush()

   303                 if rendered is None:

   304                     if args:

   305                         rendered = msg % args

   306                     else:

   307                         rendered = msg

   308                     rendered = ' '*self.indent + rendered

   309                 if hasattr(consumer, 'write'):

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

   311                 else:

   312                     consumer(rendered)

   313 

   314     def start_progress(self, msg):

   315         assert not self.in_progress, (

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

   317             % (msg, self.in_progress))

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

   319             sys.stdout.write(msg)

   320             sys.stdout.flush()

   321             self.in_progress_hanging = True

   322         else:

   323             self.in_progress_hanging = False

   324         self.in_progress = msg

   325 

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

   327         assert self.in_progress, (

   328             "Tried to end_progress without start_progress")

   329         if self.stdout_level_matches(self.NOTIFY):

   330             if not self.in_progress_hanging:

   331                 # Some message has been printed out since start_progress

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

   333                 sys.stdout.flush()

   334             else:

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

   336                 sys.stdout.flush()

   337         self.in_progress = None

   338         self.in_progress_hanging = False

   339 

   340     def show_progress(self):

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

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

   343         if self.in_progress_hanging:

   344             sys.stdout.write('.')

   345             sys.stdout.flush()

   346 

   347     def stdout_level_matches(self, level):

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

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

   350 

   351     def _stdout_level(self):

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

   353         for level, consumer in self.consumers:

   354             if consumer is sys.stdout:

   355                 return level

   356         return self.FATAL

   357 

   358     def level_matches(self, level, consumer_level):

   359         """

   360         >>> l = Logger([])

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

   362         False

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

   364         True

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

   366         False

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

   368         True

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

   370         True

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

   372         False

   373         """

   374         if isinstance(level, slice):

   375             start, stop = level.start, level.stop

   376             if start is not None and start > consumer_level:

   377                 return False

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

   379                 return False

   380             return True

   381         else:

   382             return level >= consumer_level

   383 

   384     #@classmethod

   385     def level_for_integer(cls, level):

   386         levels = cls.LEVELS

   387         if level < 0:

   388             return levels[0]

   389         if level >= len(levels):

   390             return levels[-1]

   391         return levels[level]

   392 

   393     level_for_integer = classmethod(level_for_integer)

   394 

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

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

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

   398 

   399 def mkdir(path):

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

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

   402         os.makedirs(path)

   403     else:

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

   405 

   406 def copyfileordir(src, dest):

   407     if os.path.isdir(src):

   408         shutil.copytree(src, dest, True)

   409     else:

   410         shutil.copy2(src, dest)

   411 

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

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

   414         # Some bad symlink in the src

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

   416         return

   417     if os.path.exists(dest):

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

   419         return

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

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

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

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

   424         srcpath = os.path.abspath(src)

   425     else:

   426         srcpath = os.readlink(src)

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

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

   429         try:

   430             os.symlink(srcpath, dest)

   431         except (OSError, NotImplementedError):

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

   433             copyfileordir(src, dest)

   434     else:

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

   436         copyfileordir(src, dest)

   437 

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

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

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

   441         f = open(dest, 'wb')

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

   443         f.close()

   444         return

   445     else:

   446         f = open(dest, 'rb')

   447         c = f.read()

   448         f.close()

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

   450             if not overwrite:

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

   452                 return

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

   454             f = open(dest, 'wb')

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

   456             f.close()

   457         else:

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

   459 

   460 def rmtree(dir):

   461     if os.path.exists(dir):

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

   463         shutil.rmtree(dir)

   464     else:

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

   466 

   467 def make_exe(fn):

   468     if hasattr(os, 'chmod'):

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

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

   471         os.chmod(fn, newmode)

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

   473 

   474 def _find_file(filename, dirs):

   475     for dir in reversed(dirs):

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

   477         if files and os.path.exists(files[0]):

   478             return files[0]

   479     return filename

   480 

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

   482                  search_dirs=None, never_download=False):

   483 

   484     if search_dirs is None:

   485         search_dirs = file_search_dirs()

   486 

   487     if not distribute:

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

   489         project_name = 'setuptools'

   490         bootstrap_script = EZ_SETUP_PY

   491         source = None

   492     else:

   493         setup_fn = None

   494         source = 'distribute-*.tar.gz'

   495         project_name = 'distribute'

   496         bootstrap_script = DISTRIBUTE_SETUP_PY

   497 

   498     if setup_fn is not None:

   499         setup_fn = _find_file(setup_fn, search_dirs)

   500 

   501     if source is not None:

   502         source = _find_file(source, search_dirs)

   503 

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

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

   506         # argument with newlines

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

   508         os.write(fd, bootstrap_script)

   509         os.close(fd)

   510         cmd = [py_executable, ez_setup]

   511     else:

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

   513     if unzip:

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

   515     env = {}

   516     remove_from_env = ['__PYVENV_LAUNCHER__']

   517     if logger.stdout_level_matches(logger.DEBUG):

   518         cmd.append('-v')

   519 

   520     old_chdir = os.getcwd()

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

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

   523         cmd.append(setup_fn)

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

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

   526         else:

   527             env['PYTHONPATH'] = setup_fn

   528     else:

   529         # the source is found, let's chdir

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

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

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

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

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

   535             # site.py that it's in virtualenv_support

   536             remove_from_env.append('PYTHONPATH')

   537         else:

   538             if never_download:

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

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

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

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

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

   544                                                 setup_fn or source,

   545                                                 search_dirs))

   546                 sys.exit(1)

   547 

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

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

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

   551     logger.indent += 2

   552     cwd = None

   553     if project_name == 'distribute':

   554         env['DONT_PATCH_SETUPTOOLS'] = 'true'

   555 

   556     def _filter_ez_setup(line):

   557         return filter_ez_setup(line, project_name)

   558 

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

   560         cwd = tempfile.mkdtemp()

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

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

   563             # tarball to a temp dir

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

   565             shutil.copy(source, target)

   566     try:

   567         call_subprocess(cmd, show_stdout=False,

   568                         filter_stdout=_filter_ez_setup,

   569                         extra_env=env,

   570                         remove_from_env=remove_from_env,

   571                         cwd=cwd)

   572     finally:

   573         logger.indent -= 2

   574         logger.end_progress()

   575         if cwd is not None:

   576             shutil.rmtree(cwd)

   577         if os.getcwd() != old_chdir:

   578             os.chdir(old_chdir)

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

   580             os.remove(ez_setup)

   581 

   582 def file_search_dirs():

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

   584     dirs = ['.', here,

   585             join(here, 'virtualenv_support')]

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

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

   588         try:

   589             import virtualenv

   590         except ImportError:

   591             pass

   592         else:

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

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

   595 

   596 def install_setuptools(py_executable, unzip=False,

   597                        search_dirs=None, never_download=False):

   598     _install_req(py_executable, unzip,

   599                  search_dirs=search_dirs, never_download=never_download)

   600 

   601 def install_distribute(py_executable, unzip=False,

   602                        search_dirs=None, never_download=False):

   603     _install_req(py_executable, unzip, distribute=True,

   604                  search_dirs=search_dirs, never_download=never_download)

   605 

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

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

   608     if search_dirs is None:

   609         search_dirs = file_search_dirs()

   610 

   611     filenames = []

   612     for dir in search_dirs:

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

   614                           if _pip_re.search(fn)])

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

   616     filenames.sort()

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

   618     if not filenames:

   619         filename = 'pip'

   620     else:

   621         filename = filenames[-1]

   622     easy_install_script = 'easy_install'

   623     if is_win:

   624         easy_install_script = 'easy_install-script.py'

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

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

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

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

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

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

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

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

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

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

   635     if is_jython or is_pypy:

   636         cmd.remove('-x')

   637     if filename == 'pip':

   638         if never_download:

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

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

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

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

   643                          "locations: %r" % search_dirs)

   644             sys.exit(1)

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

   646     else:

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

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

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

   650     logger.indent += 2

   651     def _filter_setup(line):

   652         return filter_ez_setup(line, 'pip')

   653     try:

   654         call_subprocess(cmd, show_stdout=False,

   655                         filter_stdout=_filter_setup)

   656     finally:

   657         logger.indent -= 2

   658         logger.end_progress()

   659 

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

   661     if not line.strip():

   662         return Logger.DEBUG

   663     if project_name == 'distribute':

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

   665                        'Scanning', 'Setuptools', 'Egg', 'Already',

   666                        'running', 'writing', 'reading', 'installing',

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

   668                        'Processing'):

   669             if line.startswith(prefix):

   670                 return Logger.DEBUG

   671         return Logger.DEBUG

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

   673                    'Copying setuptools', 'Adding setuptools',

   674                    'Installing ', 'Installed ']:

   675         if line.startswith(prefix):

   676             return Logger.DEBUG

   677     return Logger.INFO

   678 

   679 

   680 class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):

   681     """

   682     Custom help formatter for use in ConfigOptionParser that updates

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

   684     in the help listing

   685     """

   686     def expand_default(self, option):

   687         if self.parser is not None:

   688             self.parser.update_defaults(self.parser.defaults)

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

   690 

   691 

   692 class ConfigOptionParser(optparse.OptionParser):

   693     """

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

   695     configuration files and environmental variables

   696     """

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

   698         self.config = ConfigParser.RawConfigParser()

   699         self.files = self.get_config_files()

   700         self.config.read(self.files)

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

   702 

   703     def get_config_files(self):

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

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

   706             return [config_file]

   707         return [default_config_file]

   708 

   709     def update_defaults(self, defaults):

   710         """

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

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

   713         options (lists).

   714         """

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

   716         config = {}

   717         # 1. config files

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

   719         # 2. environmental variables

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

   721         # Then set the options with those values

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

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

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

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

   726             option = self.get_option(key)

   727             if option is not None:

   728                 # ignore empty values

   729                 if not val:

   730                     continue

   731                 # handle multiline configs

   732                 if option.action == 'append':

   733                     val = val.split()

   734                 else:

   735                     option.nargs = 1

   736                 if option.action == 'store_false':

   737                     val = not strtobool(val)

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

   739                     val = strtobool(val)

   740                 try:

   741                     val = option.convert_value(key, val)

   742                 except optparse.OptionValueError:

   743                     e = sys.exc_info()[1]

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

   745                     sys.exit(3)

   746                 defaults[option.dest] = val

   747         return defaults

   748 

   749     def get_config_section(self, name):

   750         """

   751         Get a section of a configuration

   752         """

   753         if self.config.has_section(name):

   754             return self.config.items(name)

   755         return []

   756 

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

   758         """

   759         Returns a generator with all environmental vars with prefix VIRTUALENV

   760         """

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

   762             if key.startswith(prefix):

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

   764 

   765     def get_default_values(self):

   766         """

   767         Overridding to make updating the defaults after instantiation of

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

   769         """

   770         if not self.process_default_values:

   771             # Old, pre-Optik 1.5 behaviour.

   772             return optparse.Values(self.defaults)

   773 

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

   775         for option in self._get_all_options():

   776             default = defaults.get(option.dest)

   777             if isinstance(default, basestring):

   778                 opt_str = option.get_opt_string()

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

   780         return optparse.Values(defaults)

   781 

   782 

   783 def main():

   784     parser = ConfigOptionParser(

   785         version=virtualenv_version,

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

   787         formatter=UpdatingDefaultsHelpFormatter())

   788 

   789     parser.add_option(

   790         '-v', '--verbose',

   791         action='count',

   792         dest='verbose',

   793         default=0,

   794         help="Increase verbosity")

   795 

   796     parser.add_option(

   797         '-q', '--quiet',

   798         action='count',

   799         dest='quiet',

   800         default=0,

   801         help='Decrease verbosity')

   802 

   803     parser.add_option(

   804         '-p', '--python',

   805         dest='python',

   806         metavar='PYTHON_EXE',

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

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

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

   810 

   811     parser.add_option(

   812         '--clear',

   813         dest='clear',

   814         action='store_true',

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

   816 

   817     parser.set_defaults(system_site_packages=False)

   818     parser.add_option(

   819         '--no-site-packages',

   820         dest='system_site_packages',

   821         action='store_false',

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

   823              "virtual environment (default)")

   824 

   825     parser.add_option(

   826         '--system-site-packages',

   827         dest='system_site_packages',

   828         action='store_true',

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

   830              "virtual environment")

   831 

   832     parser.add_option(

   833         '--unzip-setuptools',

   834         dest='unzip_setuptools',

   835         action='store_true',

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

   837 

   838     parser.add_option(

   839         '--relocatable',

   840         dest='relocatable',

   841         action='store_true',

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

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

   844 

   845     parser.add_option(

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

   847         dest='use_distribute',

   848         action='store_true',

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

   850         'VIRTUALENV_DISTRIBUTE to make it the default ')

   851 

   852     default_search_dirs = file_search_dirs()

   853     parser.add_option(

   854         '--extra-search-dir',

   855         dest="search_dirs",

   856         action="append",

   857         default=default_search_dirs,

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

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

   860 

   861     parser.add_option(

   862         '--never-download',

   863         dest="never_download",

   864         action="store_true",

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

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

   867 

   868     parser.add_option(

   869         '--prompt',

   870         dest='prompt',

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

   872 

   873     if 'extend_parser' in globals():

   874         extend_parser(parser)

   875 

   876     options, args = parser.parse_args()

   877 

   878     global logger

   879 

   880     if 'adjust_options' in globals():

   881         adjust_options(options, args)

   882 

   883     verbosity = options.verbose - options.quiet

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

   885 

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

   887         env = os.environ.copy()

   888         interpreter = resolve_interpreter(options.python)

   889         if interpreter == sys.executable:

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

   891         else:

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

   893             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   894             file = __file__

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

   896                 file = file[:-1]

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

   898             raise SystemExit(popen.wait())

   899 

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

   901     if majver > 2:

   902         options.use_distribute = True

   903 

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

   905         print(

   906             "The PYTHONDONTWRITEBYTECODE environment variable is "

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

   908             "or unset PYTHONDONTWRITEBYTECODE.")

   909         sys.exit(2)

   910     if not args:

   911         print('You must provide a DEST_DIR')

   912         parser.print_help()

   913         sys.exit(2)

   914     if len(args) > 1:

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

   916             ' '.join(args)))

   917         parser.print_help()

   918         sys.exit(2)

   919 

   920     home_dir = args[0]

   921 

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

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

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

   925         sys.exit(3)

   926 

   927     if 'PYTHONHOME' in os.environ:

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

   929         del os.environ['PYTHONHOME']

   930 

   931     if options.relocatable:

   932         make_environment_relocatable(home_dir)

   933         return

   934 

   935     create_environment(home_dir,

   936                        site_packages=options.system_site_packages,

   937                        clear=options.clear,

   938                        unzip_setuptools=options.unzip_setuptools,

   939                        use_distribute=options.use_distribute,

   940                        prompt=options.prompt,

   941                        search_dirs=options.search_dirs,

   942                        never_download=options.never_download)

   943     if 'after_install' in globals():

   944         after_install(options, home_dir)

   945 

   946 def call_subprocess(cmd, show_stdout=True,

   947                     filter_stdout=None, cwd=None,

   948                     raise_on_returncode=True, extra_env=None,

   949                     remove_from_env=None):

   950     cmd_parts = []

   951     for part in cmd:

   952         if len(part) > 45:

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

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

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

   956         if hasattr(part, 'decode'):

   957             try:

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

   959             except UnicodeDecodeError:

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

   961         cmd_parts.append(part)

   962     cmd_desc = ' '.join(cmd_parts)

   963     if show_stdout:

   964         stdout = None

   965     else:

   966         stdout = subprocess.PIPE

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

   968     if extra_env or remove_from_env:

   969         env = os.environ.copy()

   970         if extra_env:

   971             env.update(extra_env)

   972         if remove_from_env:

   973             for varname in remove_from_env:

   974                 env.pop(varname, None)

   975     else:

   976         env = None

   977     try:

   978         proc = subprocess.Popen(

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

   980             cwd=cwd, env=env)

   981     except Exception:

   982         e = sys.exc_info()[1]

   983         logger.fatal(

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

   985         raise

   986     all_output = []

   987     if stdout is not None:

   988         stdout = proc.stdout

   989         encoding = sys.getdefaultencoding()

   990         fs_encoding = sys.getfilesystemencoding()

   991         while 1:

   992             line = stdout.readline()

   993             try:

   994                 line = line.decode(encoding)

   995             except UnicodeDecodeError:

   996                 line = line.decode(fs_encoding)

   997             if not line:

   998                 break

   999             line = line.rstrip()

  1000             all_output.append(line)

  1001             if filter_stdout:

  1002                 level = filter_stdout(line)

  1003                 if isinstance(level, tuple):

  1004                     level, line = level

  1005                 logger.log(level, line)

  1006                 if not logger.stdout_level_matches(level):

  1007                     logger.show_progress()

  1008             else:

  1009                 logger.info(line)

  1010     else:

  1011         proc.communicate()

  1012     proc.wait()

  1013     if proc.returncode:

  1014         if raise_on_returncode:

  1015             if all_output:

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

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

  1018             raise OSError(

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

  1020                 % (cmd_desc, proc.returncode))

  1021         else:

  1022             logger.warn(

  1023                 "Command %s had error code %s"

  1024                 % (cmd_desc, proc.returncode))

  1025 

  1026 

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

  1028                        unzip_setuptools=False, use_distribute=False,

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

  1030     """

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

  1032 

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

  1034     directory will be on the path.

  1035 

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

  1037     first be cleared.

  1038     """

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

  1040 

  1041     py_executable = os.path.abspath(install_python(

  1042         home_dir, lib_dir, inc_dir, bin_dir,

  1043         site_packages=site_packages, clear=clear))

  1044 

  1045     install_distutils(home_dir)

  1046 

  1047     if use_distribute:

  1048         install_distribute(py_executable, unzip=unzip_setuptools,

  1049                            search_dirs=search_dirs, never_download=never_download)

  1050     else:

  1051         install_setuptools(py_executable, unzip=unzip_setuptools,

  1052                            search_dirs=search_dirs, never_download=never_download)

  1053 

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

  1055 

  1056     install_activate(home_dir, bin_dir, prompt)

  1057 

  1058 def is_executable_file(fpath):

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

  1060 

  1061 def path_locations(home_dir):

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

  1063     where scripts go, etc)"""

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

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

  1066     if is_win:

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

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

  1069         # format):

  1070         mkdir(home_dir)

  1071         if ' ' in home_dir:

  1072             try:

  1073                 import win32api

  1074             except ImportError:

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

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

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

  1078                 sys.exit(3)

  1079             home_dir = win32api.GetShortPathName(home_dir)

  1080         lib_dir = join(home_dir, 'Lib')

  1081         inc_dir = join(home_dir, 'Include')

  1082         bin_dir = join(home_dir, 'Scripts')

  1083     if is_jython:

  1084         lib_dir = join(home_dir, 'Lib')

  1085         inc_dir = join(home_dir, 'Include')

  1086         bin_dir = join(home_dir, 'bin')

  1087     elif is_pypy:

  1088         lib_dir = home_dir

  1089         inc_dir = join(home_dir, 'include')

  1090         bin_dir = join(home_dir, 'bin')

  1091     elif not is_win:

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

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

  1094         if is_executable_file(multiarch_exec):

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

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

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

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

  1099             stdout, stderr = p.communicate()

  1100             # stdout.strip is needed to remove newline character

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

  1102         else:

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

  1104         bin_dir = join(home_dir, 'bin')

  1105     return home_dir, lib_dir, inc_dir, bin_dir

  1106 

  1107 

  1108 def change_prefix(filename, dst_prefix):

  1109     prefixes = [sys.prefix]

  1110 

  1111     if is_darwin:

  1112         prefixes.extend((

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

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

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

  1116             # Python 2.6 no-frameworks

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

  1118             # System Python 2.7 on OSX Mountain Lion

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

  1120 

  1121     if hasattr(sys, 'real_prefix'):

  1122         prefixes.append(sys.real_prefix)

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

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

  1125     filename = os.path.abspath(filename)

  1126     for src_prefix in prefixes:

  1127         if filename.startswith(src_prefix):

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

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

  1130                 assert relpath[0] == os.sep

  1131                 relpath = relpath[1:]

  1132             return join(dst_prefix, relpath)

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

  1134         (filename, prefixes)

  1135