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.4"  # following best practices

     8 virtualenv_version = __version__  # legacy, again

     9 

    10 import base64

    11 import sys

    12 import os

    13 import codecs

    14 import optparse

    15 import re

    16 import shutil

    17 import logging

    18 import tempfile

    19 import zlib

    20 import errno

    21 import glob

    22 import distutils.sysconfig

    23 from distutils.util import strtobool

    24 import struct

    25 import subprocess

    26 

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

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

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

    30     sys.exit(101)

    31 

    32 try:

    33     set

    34 except NameError:

    35     from sets import Set as set

    36 try:

    37     basestring

    38 except NameError:

    39     basestring = str

    40 

    41 try:

    42     import ConfigParser

    43 except ImportError:

    44     import configparser as ConfigParser

    45 

    46 join = os.path.join

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

    48 

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

    50 is_pypy = hasattr(sys, 'pypy_version_info')

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

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

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

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

    55 

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

    57 if is_win:

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

    59 else:

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

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

    62 

    63 if is_pypy:

    64     expected_exe = 'pypy'

    65 elif is_jython:

    66     expected_exe = 'jython'

    67 else:

    68     expected_exe = 'python'

    69 

    70 

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

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

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

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

    75                     'zlib']

    76 

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

    78 

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

    80 if majver == 2:

    81     if minver >= 6:

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

    83     if minver >= 7:

    84         REQUIRED_MODULES.extend(['_weakrefset'])

    85     if minver <= 3:

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

    87 elif majver == 3:

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

    89     # for different versions.

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

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

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

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

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

    95                              'reprlib'])

    96     if minver >= 2:

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

    98     if minver == 3:

    99         import sysconfig

   100         platdir = sysconfig.get_config_var('PLATDIR')

   101         REQUIRED_FILES.append(platdir)

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

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

   104         # added as 3.3 development continues.

   105         REQUIRED_MODULES.extend([

   106             #"aifc",

   107             #"antigravity",

   108             #"argparse",

   109             #"ast",

   110             #"asynchat",

   111             #"asyncore",

   112             "base64",

   113             #"bdb",

   114             #"binhex",

   115             #"bisect",

   116             #"calendar",

   117             #"cgi",

   118             #"cgitb",

   119             #"chunk",

   120             #"cmd",

   121             #"codeop",

   122             #"code",

   123             #"colorsys",

   124             #"_compat_pickle",

   125             #"compileall",

   126             #"concurrent",

   127             #"configparser",

   128             #"contextlib",

   129             #"cProfile",

   130             #"crypt",

   131             #"csv",

   132             #"ctypes",

   133             #"curses",

   134             #"datetime",

   135             #"dbm",

   136             #"decimal",

   137             #"difflib",

   138             #"dis",

   139             #"doctest",

   140             #"dummy_threading",

   141             "_dummy_thread",

   142             #"email",

   143             #"filecmp",

   144             #"fileinput",

   145             #"formatter",

   146             #"fractions",

   147             #"ftplib",

   148             #"functools",

   149             #"getopt",

   150             #"getpass",

   151             #"gettext",

   152             #"glob",

   153             #"gzip",

   154             "hashlib",

   155             #"heapq",

   156             "hmac",

   157             #"html",

   158             #"http",

   159             #"idlelib",

   160             #"imaplib",

   161             #"imghdr",

   162             "imp",

   163             "importlib",

   164             #"inspect",

   165             #"json",

   166             #"lib2to3",

   167             #"logging",

   168             #"macpath",

   169             #"macurl2path",

   170             #"mailbox",

   171             #"mailcap",

   172             #"_markupbase",

   173             #"mimetypes",

   174             #"modulefinder",

   175             #"multiprocessing",

   176             #"netrc",

   177             #"nntplib",

   178             #"nturl2path",

   179             #"numbers",

   180             #"opcode",

   181             #"optparse",

   182             #"os2emxpath",

   183             #"pdb",

   184             #"pickle",

   185             #"pickletools",

   186             #"pipes",

   187             #"pkgutil",

   188             #"platform",

   189             #"plat-linux2",

   190             #"plistlib",

   191             #"poplib",

   192             #"pprint",

   193             #"profile",

   194             #"pstats",

   195             #"pty",

   196             #"pyclbr",

   197             #"py_compile",

   198             #"pydoc_data",

   199             #"pydoc",

   200             #"_pyio",

   201             #"queue",

   202             #"quopri",

   203             #"reprlib",

   204             "rlcompleter",

   205             #"runpy",

   206             #"sched",

   207             #"shelve",

   208             #"shlex",

   209             #"smtpd",

   210             #"smtplib",

   211             #"sndhdr",

   212             #"socket",

   213             #"socketserver",

   214             #"sqlite3",

   215             #"ssl",

   216             #"stringprep",

   217             #"string",

   218             #"_strptime",

   219             #"subprocess",

   220             #"sunau",

   221             #"symbol",

   222             #"symtable",

   223             #"sysconfig",

   224             #"tabnanny",

   225             #"telnetlib",

   226             #"test",

   227             #"textwrap",

   228             #"this",

   229             #"_threading_local",

   230             #"threading",

   231             #"timeit",

   232             #"tkinter",

   233             #"tokenize",

   234             #"token",

   235             #"traceback",

   236             #"trace",

   237             #"tty",

   238             #"turtledemo",

   239             #"turtle",

   240             #"unittest",

   241             #"urllib",

   242             #"uuid",

   243             #"uu",

   244             #"wave",

   245             #"weakref",

   246             #"webbrowser",

   247             #"wsgiref",

   248             #"xdrlib",

   249             #"xml",

   250             #"xmlrpc",

   251             #"zipfile",

   252         ])

   253 

   254 if is_pypy:

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

   256     # during the bootstrap

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

   258 

   259 class Logger(object):

   260 

   261     """

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

   263     levels, to avoid some redundancy of displayed information.

   264     """

   265 

   266     DEBUG = logging.DEBUG

   267     INFO = logging.INFO

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

   269     WARN = WARNING = logging.WARN

   270     ERROR = logging.ERROR

   271     FATAL = logging.FATAL

   272 

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

   274 

   275     def __init__(self, consumers):

   276         self.consumers = consumers

   277         self.indent = 0

   278         self.in_progress = None

   279         self.in_progress_hanging = False

   280 

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

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

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

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

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

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

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

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

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

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

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

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

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

   294         if args:

   295             if kw:

   296                 raise TypeError(

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

   298         args = args or kw

   299         rendered = None

   300         for consumer_level, consumer in self.consumers:

   301             if self.level_matches(level, consumer_level):

   302                 if (self.in_progress_hanging

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

   304                     self.in_progress_hanging = False

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

   306                     sys.stdout.flush()

   307                 if rendered is None:

   308                     if args:

   309                         rendered = msg % args

   310                     else:

   311                         rendered = msg

   312                     rendered = ' '*self.indent + rendered

   313                 if hasattr(consumer, 'write'):

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

   315                 else:

   316                     consumer(rendered)

   317 

   318     def start_progress(self, msg):

   319         assert not self.in_progress, (

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

   321             % (msg, self.in_progress))

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

   323             sys.stdout.write(msg)

   324             sys.stdout.flush()

   325             self.in_progress_hanging = True

   326         else:

   327             self.in_progress_hanging = False

   328         self.in_progress = msg

   329 

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

   331         assert self.in_progress, (

   332             "Tried to end_progress without start_progress")

   333         if self.stdout_level_matches(self.NOTIFY):

   334             if not self.in_progress_hanging:

   335                 # Some message has been printed out since start_progress

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

   337                 sys.stdout.flush()

   338             else:

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

   340                 sys.stdout.flush()

   341         self.in_progress = None

   342         self.in_progress_hanging = False

   343 

   344     def show_progress(self):

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

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

   347         if self.in_progress_hanging:

   348             sys.stdout.write('.')

   349             sys.stdout.flush()

   350 

   351     def stdout_level_matches(self, level):

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

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

   354 

   355     def _stdout_level(self):

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

   357         for level, consumer in self.consumers:

   358             if consumer is sys.stdout:

   359                 return level

   360         return self.FATAL

   361 

   362     def level_matches(self, level, consumer_level):

   363         """

   364         >>> l = Logger([])

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

   366         False

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

   368         True

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

   370         False

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

   372         True

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

   374         True

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

   376         False

   377         """

   378         if isinstance(level, slice):

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

   380             if start is not None and start > consumer_level:

   381                 return False

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

   383                 return False

   384             return True

   385         else:

   386             return level >= consumer_level

   387 

   388     #@classmethod

   389     def level_for_integer(cls, level):

   390         levels = cls.LEVELS

   391         if level < 0:

   392             return levels[0]

   393         if level >= len(levels):

   394             return levels[-1]

   395         return levels[level]

   396 

   397     level_for_integer = classmethod(level_for_integer)

   398 

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

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

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

   402 

   403 def mkdir(path):

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

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

   406         os.makedirs(path)

   407     else:

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

   409 

   410 def copyfileordir(src, dest):

   411     if os.path.isdir(src):

   412         shutil.copytree(src, dest, True)

   413     else:

   414         shutil.copy2(src, dest)

   415 

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

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

   418         # Some bad symlink in the src

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

   420         return

   421     if os.path.exists(dest):

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

   423         return

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

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

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

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

   428         srcpath = os.path.abspath(src)

   429     else:

   430         srcpath = os.readlink(src)

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

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

   433         try:

   434             os.symlink(srcpath, dest)

   435         except (OSError, NotImplementedError):

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

   437             copyfileordir(src, dest)

   438     else:

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

   440         copyfileordir(src, dest)

   441 

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

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

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

   445         f = open(dest, 'wb')

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

   447         f.close()

   448         return

   449     else:

   450         f = open(dest, 'rb')

   451         c = f.read()

   452         f.close()

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

   454             if not overwrite:

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

   456                 return

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

   458             f = open(dest, 'wb')

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

   460             f.close()

   461         else:

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

   463 

   464 def rmtree(dir):

   465     if os.path.exists(dir):

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

   467         shutil.rmtree(dir)

   468     else:

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

   470 

   471 def make_exe(fn):

   472     if hasattr(os, 'chmod'):

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

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

   475         os.chmod(fn, newmode)

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

   477 

   478 def _find_file(filename, dirs):

   479     for dir in reversed(dirs):

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

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

   482             return True, files[0]

   483     return False, filename

   484 

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

   486                  search_dirs=None, never_download=False):

   487 

   488     if search_dirs is None:

   489         search_dirs = file_search_dirs()

   490 

   491     if not distribute:

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

   493         found, egg_path = _find_file(egg_path, search_dirs)

   494         project_name = 'setuptools'

   495         bootstrap_script = EZ_SETUP_PY

   496         tgz_path = None

   497     else:

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

   499         # but can be made available by the user)

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

   501         found, egg_path = _find_file(egg_path, search_dirs)

   502         project_name = 'distribute'

   503         if found:

   504             tgz_path = None

   505             bootstrap_script = DISTRIBUTE_FROM_EGG_PY

   506         else:

   507             # Fall back to sdist

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

   509             # iff bootstrap_script is a generic setup script accepting

   510             # the standard arguments.

   511             egg_path = None

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

   513             found, tgz_path = _find_file(tgz_path, search_dirs)

   514             bootstrap_script = DISTRIBUTE_SETUP_PY

   515 

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

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

   518         # argument with newlines

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

   520         os.write(fd, bootstrap_script)

   521         os.close(fd)

   522         cmd = [py_executable, ez_setup]

   523     else:

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

   525     if unzip and egg_path:

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

   527     env = {}

   528     remove_from_env = ['__PYVENV_LAUNCHER__']

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

   530         cmd.append('-v')

   531 

   532     old_chdir = os.getcwd()

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

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

   535         cmd.append(egg_path)

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

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

   538         else:

   539             env['PYTHONPATH'] = egg_path

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

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

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

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

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

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

   546         # site.py that it's in virtualenv_support

   547         remove_from_env.append('PYTHONPATH')

   548     elif never_download:

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

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

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

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

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

   554                                         egg_path or tgz_path,

   555                                         search_dirs))

   556         sys.exit(1)

   557     elif egg_path:

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

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

   560     else:

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

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

   563     logger.indent += 2

   564     cwd = None

   565     if project_name == 'distribute':

   566         env['DONT_PATCH_SETUPTOOLS'] = 'true'

   567 

   568     def _filter_ez_setup(line):

   569         return filter_ez_setup(line, project_name)

   570 

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

   572         cwd = tempfile.mkdtemp()

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

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

   575             # tarball to a temp dir

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

   577             shutil.copy(tgz_path, target)

   578     try:

   579         call_subprocess(cmd, show_stdout=False,

   580                         filter_stdout=_filter_ez_setup,

   581                         extra_env=env,

   582                         remove_from_env=remove_from_env,

   583                         cwd=cwd)

   584     finally:

   585         logger.indent -= 2

   586         logger.end_progress()

   587         if cwd is not None:

   588             shutil.rmtree(cwd)

   589         if os.getcwd() != old_chdir:

   590             os.chdir(old_chdir)

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

   592             os.remove(ez_setup)

   593 

   594 def file_search_dirs():

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

   596     dirs = ['.', here,

   597             join(here, 'virtualenv_support')]

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

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

   600         try:

   601             import virtualenv

   602         except ImportError:

   603             pass

   604         else:

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

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

   607 

   608 def install_setuptools(py_executable, unzip=False,

   609                        search_dirs=None, never_download=False):

   610     _install_req(py_executable, unzip,

   611                  search_dirs=search_dirs, never_download=never_download)

   612 

   613 def install_distribute(py_executable, unzip=False,

   614                        search_dirs=None, never_download=False):

   615     _install_req(py_executable, unzip, distribute=True,

   616                  search_dirs=search_dirs, never_download=never_download)

   617 

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

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

   620     if search_dirs is None:

   621         search_dirs = file_search_dirs()

   622 

   623     filenames = []

   624     for dir in search_dirs:

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

   626                           if _pip_re.search(fn)])

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

   628     filenames.sort()

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

   630     if not filenames:

   631         filename = 'pip'

   632     else:

   633         filename = filenames[-1]

   634     easy_install_script = 'easy_install'

   635     if is_win:

   636         easy_install_script = 'easy_install-script.py'

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

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

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

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

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

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

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

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

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

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

   647     if is_jython or is_pypy:

   648         cmd.remove('-x')

   649     if filename == 'pip':

   650         if never_download:

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

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

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

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

   655                          "locations: %r" % search_dirs)

   656             sys.exit(1)

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

   658     else:

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

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

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

   662     logger.indent += 2

   663     def _filter_setup(line):

   664         return filter_ez_setup(line, 'pip')

   665     try:

   666         call_subprocess(cmd, show_stdout=False,

   667                         filter_stdout=_filter_setup)

   668     finally:

   669         logger.indent -= 2

   670         logger.end_progress()

   671 

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

   673     if not line.strip():

   674         return Logger.DEBUG

   675     if project_name == 'distribute':

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

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

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

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

   680                        'Processing'):

   681             if line.startswith(prefix):

   682                 return Logger.DEBUG

   683         return Logger.DEBUG

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

   685                    'Copying setuptools', 'Adding setuptools',

   686                    'Installing ', 'Installed ']:

   687         if line.startswith(prefix):

   688             return Logger.DEBUG

   689     return Logger.INFO

   690 

   691 

   692 class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):

   693     """

   694     Custom help formatter for use in ConfigOptionParser that updates

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

   696     in the help listing

   697     """

   698     def expand_default(self, option):

   699         if self.parser is not None:

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

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

   702 

   703 

   704 class ConfigOptionParser(optparse.OptionParser):

   705     """

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

   707     configuration files and environmental variables

   708     """

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

   710         self.config = ConfigParser.RawConfigParser()

   711         self.files = self.get_config_files()

   712         self.config.read(self.files)

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

   714 

   715     def get_config_files(self):

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

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

   718             return [config_file]

   719         return [default_config_file]

   720 

   721     def update_defaults(self, defaults):

   722         """

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

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

   725         options (lists).

   726         """

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

   728         config = {}

   729         # 1. config files

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

   731         # 2. environmental variables

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

   733         # Then set the options with those values

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

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

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

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

   738             option = self.get_option(key)

   739             if option is not None:

   740                 # ignore empty values

   741                 if not val:

   742                     continue

   743                 # handle multiline configs

   744                 if option.action == 'append':

   745                     val = val.split()

   746                 else:

   747                     option.nargs = 1

   748                 if option.action == 'store_false':

   749                     val = not strtobool(val)

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

   751                     val = strtobool(val)

   752                 try:

   753                     val = option.convert_value(key, val)

   754                 except optparse.OptionValueError:

   755                     e = sys.exc_info()[1]

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

   757                     sys.exit(3)

   758                 defaults[option.dest] = val

   759         return defaults

   760 

   761     def get_config_section(self, name):

   762         """

   763         Get a section of a configuration

   764         """

   765         if self.config.has_section(name):

   766             return self.config.items(name)

   767         return []

   768 

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

   770         """

   771         Returns a generator with all environmental vars with prefix VIRTUALENV

   772         """

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

   774             if key.startswith(prefix):

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

   776 

   777     def get_default_values(self):

   778         """

   779         Overridding to make updating the defaults after instantiation of

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

   781         """

   782         if not self.process_default_values:

   783             # Old, pre-Optik 1.5 behaviour.

   784             return optparse.Values(self.defaults)

   785 

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

   787         for option in self._get_all_options():

   788             default = defaults.get(option.dest)

   789             if isinstance(default, basestring):

   790                 opt_str = option.get_opt_string()

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

   792         return optparse.Values(defaults)

   793 

   794 

   795 def main():

   796     parser = ConfigOptionParser(

   797         version=virtualenv_version,

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

   799         formatter=UpdatingDefaultsHelpFormatter())

   800 

   801     parser.add_option(

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

   803         action='count',

   804         dest='verbose',

   805         default=0,

   806         help="Increase verbosity")

   807 

   808     parser.add_option(

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

   810         action='count',

   811         dest='quiet',

   812         default=0,

   813         help='Decrease verbosity')

   814 

   815     parser.add_option(

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

   817         dest='python',

   818         metavar='PYTHON_EXE',

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

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

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

   822 

   823     parser.add_option(

   824         '--clear',

   825         dest='clear',

   826         action='store_true',

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

   828 

   829     parser.set_defaults(system_site_packages=False)

   830     parser.add_option(

   831         '--no-site-packages',

   832         dest='system_site_packages',

   833         action='store_false',

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

   835              "virtual environment (default)")

   836 

   837     parser.add_option(

   838         '--system-site-packages',

   839         dest='system_site_packages',

   840         action='store_true',

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

   842              "virtual environment")

   843 

   844     parser.add_option(

   845         '--unzip-setuptools',

   846         dest='unzip_setuptools',

   847         action='store_true',

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

   849 

   850     parser.add_option(

   851         '--relocatable',

   852         dest='relocatable',

   853         action='store_true',

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

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

   856 

   857     parser.add_option(

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

   859         dest='use_distribute',

   860         action='store_true',

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

   862         'VIRTUALENV_DISTRIBUTE to make it the default ')

   863 

   864     parser.add_option(

   865         '--setuptools',

   866         dest='use_distribute',

   867         action='store_false',

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

   869         'VIRTUALENV_SETUPTOOLS to make it the default ')

   870 

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

   872     parser.set_defaults(use_distribute=False)

   873 

   874     default_search_dirs = file_search_dirs()

   875     parser.add_option(

   876         '--extra-search-dir',

   877         dest="search_dirs",

   878         action="append",

   879         default=default_search_dirs,

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

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

   882 

   883     parser.add_option(

   884         '--never-download',

   885         dest="never_download",

   886         action="store_true",

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

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

   889 

   890     parser.add_option(

   891         '--prompt',

   892         dest='prompt',

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

   894 

   895     if 'extend_parser' in globals():

   896         extend_parser(parser)

   897 

   898     options, args = parser.parse_args()

   899 

   900     global logger

   901 

   902     if 'adjust_options' in globals():

   903         adjust_options(options, args)

   904 

   905     verbosity = options.verbose - options.quiet

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

   907 

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

   909         env = os.environ.copy()

   910         interpreter = resolve_interpreter(options.python)

   911         if interpreter == sys.executable:

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

   913         else:

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

   915             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   916             file = __file__

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

   918                 file = file[:-1]

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

   920             raise SystemExit(popen.wait())

   921 

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

   923     if majver > 2:

   924         options.use_distribute = True

   925 

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

   927         print(

   928             "The PYTHONDONTWRITEBYTECODE environment variable is "

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

   930             "or unset PYTHONDONTWRITEBYTECODE.")

   931         sys.exit(2)

   932     if not args:

   933         print('You must provide a DEST_DIR')

   934         parser.print_help()

   935         sys.exit(2)

   936     if len(args) > 1:

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

   938             ' '.join(args)))

   939         parser.print_help()

   940         sys.exit(2)

   941 

   942     home_dir = args[0]

   943 

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

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

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

   947         sys.exit(3)

   948 

   949     if 'PYTHONHOME' in os.environ:

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

   951         del os.environ['PYTHONHOME']

   952 

   953     if options.relocatable:

   954         make_environment_relocatable(home_dir)

   955         return

   956 

   957     create_environment(home_dir,

   958                        site_packages=options.system_site_packages,

   959                        clear=options.clear,

   960                        unzip_setuptools=options.unzip_setuptools,

   961                        use_distribute=options.use_distribute,

   962                        prompt=options.prompt,

   963                        search_dirs=options.search_dirs,

   964                        never_download=options.never_download)

   965     if 'after_install' in globals():

   966         after_install(options, home_dir)

   967 

   968 def call_subprocess(cmd, show_stdout=True,

   969                     filter_stdout=None, cwd=None,

   970                     raise_on_returncode=True, extra_env=None,

   971                     remove_from_env=None):

   972     cmd_parts = []

   973     for part in cmd:

   974         if len(part) > 45:

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

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

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

   978         if hasattr(part, 'decode'):

   979             try:

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

   981             except UnicodeDecodeError:

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

   983         cmd_parts.append(part)

   984     cmd_desc = ' '.join(cmd_parts)

   985     if show_stdout:

   986         stdout = None

   987     else:

   988         stdout = subprocess.PIPE

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

   990     if extra_env or remove_from_env:

   991         env = os.environ.copy()

   992         if extra_env:

   993             env.update(extra_env)

   994         if remove_from_env:

   995             for varname in remove_from_env:

   996                 env.pop(varname, None)

   997     else:

   998         env = None

   999     try:

  1000         proc = subprocess.Popen(

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

  1002             cwd=cwd, env=env)

  1003     except Exception:

  1004         e = sys.exc_info()[1]

  1005         logger.fatal(

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

  1007         raise

  1008     all_output = []

  1009     if stdout is not None:

  1010         stdout = proc.stdout

  1011         encoding = sys.getdefaultencoding()

  1012         fs_encoding = sys.getfilesystemencoding()

  1013         while 1:

  1014             line = stdout.readline()

  1015             try:

  1016                 line = line.decode(encoding)

  1017             except UnicodeDecodeError:

  1018                 line = line.decode(fs_encoding)

  1019             if not line:

  1020                 break

  1021             line = line.rstrip()

  1022             all_output.append(line)

  1023             if filter_stdout:

  1024                 level = filter_stdout(line)

  1025                 if isinstance(level, tuple):

  1026                     level, line = level

  1027                 logger.log(level, line)

  1028                 if not logger.stdout_level_matches(level):

  1029                     logger.show_progress()

  1030             else:

  1031                 logger.info(line)

  1032     else:

  1033         proc.communicate()

  1034     proc.wait()

  1035     if proc.returncode:

  1036         if raise_on_returncode:

  1037             if all_output:

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

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

  1040             raise OSError(

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

  1042                 % (cmd_desc, proc.returncode))

  1043         else:

  1044             logger.warn(

  1045                 "Command %s had error code %s"

  1046                 % (cmd_desc, proc.returncode))

  1047 

  1048 

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

  1050                        unzip_setuptools=False, use_distribute=False,

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

  1052     """

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

  1054 

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

  1056     directory will be on the path.

  1057 

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

  1059     first be cleared.

  1060     """

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

  1062 

  1063     py_executable = os.path.abspath(install_python(

  1064         home_dir, lib_dir, inc_dir, bin_dir,

  1065         site_packages=site_packages, clear=clear))

  1066 

  1067     install_distutils(home_dir)

  1068 

  1069     if use_distribute:

  1070         install_distribute(py_executable, unzip=unzip_setuptools,

  1071                            search_dirs=search_dirs, never_download=never_download)

  1072     else:

  1073         install_setuptools(py_executable, unzip=unzip_setuptools,

  1074                            search_dirs=search_dirs, never_download=never_download)

  1075 

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

  1077 

  1078     install_activate(home_dir, bin_dir, prompt)

  1079 

  1080 def is_executable_file(fpath):

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

  1082 

  1083 def path_locations(home_dir):

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

  1085     where scripts go, etc)"""

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

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

  1088     if is_win:

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

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

  1091         # format):

  1092         mkdir(home_dir)

  1093         if ' ' in home_dir:

  1094             import ctypes

  1095             GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW

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

  1097             buf = ctypes.create_unicode_buffer(size)

  1098             try:

  1099                 u = unicode

  1100             except NameError:

  1101                 u = str

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

  1103             if not ret:

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

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

  1106                 print('Exiting.')

  1107                 sys.exit(3)

  1108             home_dir = str(buf.value)

  1109         lib_dir = join(home_dir, 'Lib')

  1110         inc_dir = join(home_dir, 'Include')

  1111         bin_dir = join(home_dir, 'Scripts')

  1112     if is_jython:

  1113         lib_dir = join(home_dir, 'Lib')

  1114         inc_dir = join(home_dir, 'Include')

  1115         bin_dir = join(home_dir, 'bin')

  1116     elif is_pypy:

  1117         lib_dir = home_dir

  1118         inc_dir = join(home_dir, 'include')

  1119         bin_dir = join(home_dir, 'bin')

  1120     elif not is_win:

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

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

  1123         if is_executable_file(multiarch_exec):

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

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

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

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

  1128             stdout, stderr = p.communicate()

  1129             # stdout.strip is needed to remove newline character

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

  1131         else:

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

  1133         bin_dir = join(home_dir, 'bin')

  1134     return home_dir, lib_dir, inc_dir, bin_dir

  1135