1 #!/usr/bin/env python2.6

     2 ## WARNING: This file is generated

     3 #!/usr/bin/env python

     4 """Create a "virtual" Python installation

     5 """

     6 

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

     8 # and docs/conf.py as well.

     9 virtualenv_version = "1.6.4"

    10 

    11 import base64

    12 import sys

    13 import os

    14 import optparse

    15 import re

    16 import shutil

    17 import logging

    18 import tempfile

    19 import zlib

    20 import errno

    21 import distutils.sysconfig

    22 try:

    23     import subprocess

    24 except ImportError:

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

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

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

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

    29         sys.exit(101)

    30     else:

    31         raise

    32 try:

    33     set

    34 except NameError:

    35     from sets import Set as set

    36 try:

    37     basestring

    38 except NameError:

    39     basestring = str

    40 

    41 join = os.path.join

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

    43 

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

    45 is_pypy = hasattr(sys, 'pypy_version_info')

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

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

    48 

    49 if is_pypy:

    50     expected_exe = 'pypy'

    51 elif is_jython:

    52     expected_exe = 'jython'

    53 else:

    54     expected_exe = 'python'

    55 

    56 

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

    58                     'fnmatch', 'locale', 'encodings', 'codecs',

    59                     'stat', 'UserDict', 'readline', 'copy_reg', 'types',

    60                     're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',

    61                     'zlib']

    62 

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

    64 

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

    66 if majver == 2:

    67     if minver >= 6:

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

    69     if minver >= 7:

    70         REQUIRED_MODULES.extend(['_weakrefset'])

    71     if minver <= 3:

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

    73 elif majver == 3:

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

    75     # for different versions.

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

    77                              '_weakrefset', 'copyreg', 'tempfile', 'random',

    78                              '__future__', 'collections', 'keyword', 'tarfile',

    79                              'shutil', 'struct', 'copy'])

    80     if minver >= 2:

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

    82     if minver == 3:

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

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

    85         # added as 3.3 development continues.

    86         REQUIRED_MODULES.extend([

    87             #"aifc",

    88             #"antigravity",

    89             #"argparse",

    90             #"ast",

    91             #"asynchat",

    92             #"asyncore",

    93             "base64",

    94             #"bdb",

    95             #"binhex",

    96             "bisect",

    97             #"calendar",

    98             #"cgi",

    99             #"cgitb",

   100             #"chunk",

   101             #"cmd",

   102             #"codeop",

   103             #"code",

   104             #"colorsys",

   105             #"_compat_pickle",

   106             #"compileall",

   107             #"concurrent",

   108             #"configparser",

   109             #"contextlib",

   110             #"cProfile",

   111             #"crypt",

   112             #"csv",

   113             #"ctypes",

   114             #"curses",

   115             #"datetime",

   116             #"dbm",

   117             #"decimal",

   118             #"difflib",

   119             #"dis",

   120             #"doctest",

   121             #"dummy_threading",

   122             "_dummy_thread",

   123             #"email",

   124             #"filecmp",

   125             #"fileinput",

   126             #"formatter",

   127             #"fractions",

   128             #"ftplib",

   129             #"functools",

   130             #"getopt",

   131             #"getpass",

   132             #"gettext",

   133             #"glob",

   134             #"gzip",

   135             "hashlib",

   136             "heapq",

   137             "hmac",

   138             #"html",

   139             #"http",

   140             #"idlelib",

   141             #"imaplib",

   142             #"imghdr",

   143             #"importlib",

   144             #"inspect",

   145             #"json",

   146             #"lib2to3",

   147             #"logging",

   148             #"macpath",

   149             #"macurl2path",

   150             #"mailbox",

   151             #"mailcap",

   152             #"_markupbase",

   153             #"mimetypes",

   154             #"modulefinder",

   155             #"multiprocessing",

   156             #"netrc",

   157             #"nntplib",

   158             #"nturl2path",

   159             #"numbers",

   160             #"opcode",

   161             #"optparse",

   162             #"os2emxpath",

   163             #"pdb",

   164             #"pickle",

   165             #"pickletools",

   166             #"pipes",

   167             #"pkgutil",

   168             #"platform",

   169             #"plat-linux2",

   170             #"plistlib",

   171             #"poplib",

   172             #"pprint",

   173             #"profile",

   174             #"pstats",

   175             #"pty",

   176             #"pyclbr",

   177             #"py_compile",

   178             #"pydoc_data",

   179             #"pydoc",

   180             #"_pyio",

   181             #"queue",

   182             #"quopri",

   183             "reprlib",

   184             "rlcompleter",

   185             #"runpy",

   186             #"sched",

   187             #"shelve",

   188             #"shlex",

   189             #"smtpd",

   190             #"smtplib",

   191             #"sndhdr",

   192             #"socket",

   193             #"socketserver",

   194             #"sqlite3",

   195             #"ssl",

   196             #"stringprep",

   197             #"string",

   198             #"_strptime",

   199             #"subprocess",

   200             #"sunau",

   201             #"symbol",

   202             #"symtable",

   203             #"sysconfig",

   204             #"tabnanny",

   205             #"telnetlib",

   206             #"test",

   207             #"textwrap",

   208             #"this",

   209             #"_threading_local",

   210             #"threading",

   211             #"timeit",

   212             #"tkinter",

   213             #"tokenize",

   214             #"token",

   215             #"traceback",

   216             #"trace",

   217             #"tty",

   218             #"turtledemo",

   219             #"turtle",

   220             #"unittest",

   221             #"urllib",

   222             #"uuid",

   223             #"uu",

   224             #"wave",

   225             "weakref",

   226             #"webbrowser",

   227             #"wsgiref",

   228             #"xdrlib",

   229             #"xml",

   230             #"xmlrpc",

   231             #"zipfile",

   232         ])

   233 

   234 if is_pypy:

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

   236     # during the bootstrap

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

   238 

   239 class Logger(object):

   240 

   241     """

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

   243     levels, to avoid some redundancy of displayed information.

   244     """

   245 

   246     DEBUG = logging.DEBUG

   247     INFO = logging.INFO

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

   249     WARN = WARNING = logging.WARN

   250     ERROR = logging.ERROR

   251     FATAL = logging.FATAL

   252 

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

   254 

   255     def __init__(self, consumers):

   256         self.consumers = consumers

   257         self.indent = 0

   258         self.in_progress = None

   259         self.in_progress_hanging = False

   260 

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

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

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

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

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

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

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

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

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

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

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

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

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

   274         if args:

   275             if kw:

   276                 raise TypeError(

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

   278         args = args or kw

   279         rendered = None

   280         for consumer_level, consumer in self.consumers:

   281             if self.level_matches(level, consumer_level):

   282                 if (self.in_progress_hanging

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

   284                     self.in_progress_hanging = False

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

   286                     sys.stdout.flush()

   287                 if rendered is None:

   288                     if args:

   289                         rendered = msg % args

   290                     else:

   291                         rendered = msg

   292                     rendered = ' '*self.indent + rendered

   293                 if hasattr(consumer, 'write'):

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

   295                 else:

   296                     consumer(rendered)

   297 

   298     def start_progress(self, msg):

   299         assert not self.in_progress, (

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

   301             % (msg, self.in_progress))

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

   303             sys.stdout.write(msg)

   304             sys.stdout.flush()

   305             self.in_progress_hanging = True

   306         else:

   307             self.in_progress_hanging = False

   308         self.in_progress = msg

   309 

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

   311         assert self.in_progress, (

   312             "Tried to end_progress without start_progress")

   313         if self.stdout_level_matches(self.NOTIFY):

   314             if not self.in_progress_hanging:

   315                 # Some message has been printed out since start_progress

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

   317                 sys.stdout.flush()

   318             else:

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

   320                 sys.stdout.flush()

   321         self.in_progress = None

   322         self.in_progress_hanging = False

   323 

   324     def show_progress(self):

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

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

   327         if self.in_progress_hanging:

   328             sys.stdout.write('.')

   329             sys.stdout.flush()

   330 

   331     def stdout_level_matches(self, level):

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

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

   334 

   335     def _stdout_level(self):

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

   337         for level, consumer in self.consumers:

   338             if consumer is sys.stdout:

   339                 return level

   340         return self.FATAL

   341 

   342     def level_matches(self, level, consumer_level):

   343         """

   344         >>> l = Logger([])

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

   346         False

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

   348         True

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

   350         False

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

   352         True

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

   354         True

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

   356         False

   357         """

   358         if isinstance(level, slice):

   359             start, stop = level.start, level.stop

   360             if start is not None and start > consumer_level:

   361                 return False

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

   363                 return False

   364             return True

   365         else:

   366             return level >= consumer_level

   367 

   368     #@classmethod

   369     def level_for_integer(cls, level):

   370         levels = cls.LEVELS

   371         if level < 0:

   372             return levels[0]

   373         if level >= len(levels):

   374             return levels[-1]

   375         return levels[level]

   376 

   377     level_for_integer = classmethod(level_for_integer)

   378 

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

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

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

   382 

   383 def mkdir(path):

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

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

   386         os.makedirs(path)

   387     else:

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

   389 

   390 def copyfileordir(src, dest):

   391     if os.path.isdir(src):

   392         shutil.copytree(src, dest, True)

   393     else:

   394         shutil.copy2(src, dest)

   395 

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

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

   398         # Some bad symlink in the src

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

   400         return

   401     if os.path.exists(dest):

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

   403         return

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

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

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

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

   408         srcpath = os.path.abspath(src)

   409     else:

   410         srcpath = os.readlink(src)

   411     if symlink and hasattr(os, 'symlink'):

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

   413         try:

   414             os.symlink(srcpath, dest)

   415         except (OSError, NotImplementedError):

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

   417             copyfileordir(src, dest)

   418     else:

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

   420         copyfileordir(src, dest)

   421 

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

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

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

   425         f = open(dest, 'wb')

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

   427         f.close()

   428         return

   429     else:

   430         f = open(dest, 'rb')

   431         c = f.read()

   432         f.close()

   433         if c != content:

   434             if not overwrite:

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

   436                 return

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

   438             f = open(dest, 'wb')

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

   440             f.close()

   441         else:

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

   443 

   444 def rmtree(dir):

   445     if os.path.exists(dir):

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

   447         shutil.rmtree(dir)

   448     else:

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

   450 

   451 def make_exe(fn):

   452     if hasattr(os, 'chmod'):

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

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

   455         os.chmod(fn, newmode)

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

   457 

   458 def _find_file(filename, dirs):

   459     for dir in dirs:

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

   461             return join(dir, filename)

   462     return filename

   463 

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

   465                  search_dirs=None, never_download=False):

   466 

   467     if search_dirs is None:

   468         search_dirs = file_search_dirs()

   469 

   470     if not distribute:

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

   472         project_name = 'setuptools'

   473         bootstrap_script = EZ_SETUP_PY

   474         source = None

   475     else:

   476         setup_fn = None

   477         source = 'distribute-0.6.19.tar.gz'

   478         project_name = 'distribute'

   479         bootstrap_script = DISTRIBUTE_SETUP_PY

   480 

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

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

   483         # definitely get the pkg_resources from the site directory of

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

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

   486         # incompatibility issues)

   487         _prev_sys_path = sys.path

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

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

   490 

   491         try:

   492             try:

   493                 # check if the global Python has distribute installed or plain

   494                 # setuptools

   495                 import pkg_resources

   496                 if not hasattr(pkg_resources, '_distribute'):

   497                     location = os.path.dirname(pkg_resources.__file__)

   498                     logger.notify("A globally installed setuptools was found (in %s)" % location)

   499                     logger.notify("Use the --no-site-packages option to use distribute in "

   500                                   "the virtualenv.")

   501             except ImportError:

   502                 pass

   503         finally:

   504             sys.path = _prev_sys_path

   505 

   506     if setup_fn is not None:

   507         setup_fn = _find_file(setup_fn, search_dirs)

   508 

   509     if source is not None:

   510         source = _find_file(source, search_dirs)

   511 

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

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

   514         # argument with newlines

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

   516         os.write(fd, bootstrap_script)

   517         os.close(fd)

   518         cmd = [py_executable, ez_setup]

   519     else:

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

   521     if unzip:

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

   523     env = {}

   524     remove_from_env = []

   525     if logger.stdout_level_matches(logger.DEBUG):

   526         cmd.append('-v')

   527 

   528     old_chdir = os.getcwd()

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

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

   531         cmd.append(setup_fn)

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

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

   534         else:

   535             env['PYTHONPATH'] = setup_fn

   536     else:

   537         # the source is found, let's chdir

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

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

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

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

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

   543             # site.py that it's in virtualenv_support

   544             remove_from_env.append('PYTHONPATH')

   545         else:

   546             if never_download:

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

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

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

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

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

   552                                                 setup_fn or source,

   553                                                 search_dirs))

   554                 sys.exit(1)

   555 

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

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

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

   559     logger.indent += 2

   560     cwd = None

   561     if project_name == 'distribute':

   562         env['DONT_PATCH_SETUPTOOLS'] = 'true'

   563 

   564     def _filter_ez_setup(line):

   565         return filter_ez_setup(line, project_name)

   566 

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

   568         cwd = tempfile.mkdtemp()

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

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

   571             # tarball to a temp dir

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

   573             shutil.copy(source, target)

   574     try:

   575         call_subprocess(cmd, show_stdout=False,

   576                         filter_stdout=_filter_ez_setup,

   577                         extra_env=env,

   578                         remove_from_env=remove_from_env,

   579                         cwd=cwd)

   580     finally:

   581         logger.indent -= 2

   582         logger.end_progress()

   583         if os.getcwd() != old_chdir:

   584             os.chdir(old_chdir)

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

   586             os.remove(ez_setup)

   587 

   588 def file_search_dirs():

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

   590     dirs = ['.', here,

   591             join(here, 'virtualenv_support')]

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

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

   594         try:

   595             import virtualenv

   596         except ImportError:

   597             pass

   598         else:

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

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

   601 

   602 def install_setuptools(py_executable, unzip=False,

   603                        search_dirs=None, never_download=False):

   604     _install_req(py_executable, unzip, 

   605                  search_dirs=search_dirs, never_download=never_download)

   606 

   607 def install_distribute(py_executable, unzip=False, 

   608                        search_dirs=None, never_download=False):

   609     _install_req(py_executable, unzip, distribute=True, 

   610                  search_dirs=search_dirs, never_download=never_download)

   611 

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

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

   614     if search_dirs is None:

   615         search_dirs = file_search_dirs()

   616 

   617     filenames = []

   618     for dir in search_dirs:

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

   620                           if _pip_re.search(fn)])

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

   622     filenames.sort()

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

   624     if not filenames:

   625         filename = 'pip'

   626     else:

   627         filename = filenames[-1]

   628     easy_install_script = 'easy_install'

   629     if sys.platform == 'win32':

   630         easy_install_script = 'easy_install-script.py'

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

   632     if filename == 'pip':

   633         if never_download:

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

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

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

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

   638                          "locations: %r" % search_dirs)

   639             sys.exit(1)

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

   641     else:

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

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

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

   645     logger.indent += 2

   646     def _filter_setup(line):

   647         return filter_ez_setup(line, 'pip')

   648     try:

   649         call_subprocess(cmd, show_stdout=False,

   650                         filter_stdout=_filter_setup)

   651     finally:

   652         logger.indent -= 2

   653         logger.end_progress()

   654 

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

   656     if not line.strip():

   657         return Logger.DEBUG

   658     if project_name == 'distribute':

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

   660                        'Scanning', 'Setuptools', 'Egg', 'Already',

   661                        'running', 'writing', 'reading', 'installing',

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

   663                        'Processing'):

   664             if line.startswith(prefix):

   665                 return Logger.DEBUG

   666         return Logger.DEBUG

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

   668                    'Copying setuptools', 'Adding setuptools',

   669                    'Installing ', 'Installed ']:

   670         if line.startswith(prefix):

   671             return Logger.DEBUG

   672     return Logger.INFO

   673 

   674 def main():

   675     parser = optparse.OptionParser(

   676         version=virtualenv_version,

   677         usage="%prog [OPTIONS] DEST_DIR")

   678 

   679     parser.add_option(

   680         '-v', '--verbose',

   681         action='count',

   682         dest='verbose',

   683         default=0,

   684         help="Increase verbosity")

   685 

   686     parser.add_option(

   687         '-q', '--quiet',

   688         action='count',

   689         dest='quiet',

   690         default=0,

   691         help='Decrease verbosity')

   692 

   693     parser.add_option(

   694         '-p', '--python',

   695         dest='python',

   696         metavar='PYTHON_EXE',

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

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

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

   700 

   701     parser.add_option(

   702         '--clear',

   703         dest='clear',

   704         action='store_true',

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

   706 

   707     parser.add_option(

   708         '--no-site-packages',

   709         dest='no_site_packages',

   710         action='store_true',

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

   712              "virtual environment")

   713 

   714     parser.add_option(

   715         '--unzip-setuptools',

   716         dest='unzip_setuptools',

   717         action='store_true',

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

   719 

   720     parser.add_option(

   721         '--relocatable',

   722         dest='relocatable',

   723         action='store_true',

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

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

   726 

   727     parser.add_option(

   728         '--distribute',

   729         dest='use_distribute',

   730         action='store_true',

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

   732         'VIRTUALENV_USE_DISTRIBUTE to make it the default ')

   733 

   734     default_search_dirs = file_search_dirs()

   735     parser.add_option(

   736         '--extra-search-dir',

   737         dest="search_dirs",

   738         action="append",

   739         default=default_search_dirs,

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

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

   742 

   743     parser.add_option(

   744         '--never-download',

   745         dest="never_download",

   746         action="store_true",

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

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

   749 

   750     parser.add_option(

   751         '--prompt=',

   752         dest='prompt',

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

   754 

   755     if 'extend_parser' in globals():

   756         extend_parser(parser)

   757 

   758     options, args = parser.parse_args()

   759 

   760     global logger

   761 

   762     if 'adjust_options' in globals():

   763         adjust_options(options, args)

   764 

   765     verbosity = options.verbose - options.quiet

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

   767 

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

   769         env = os.environ.copy()

   770         interpreter = resolve_interpreter(options.python)

   771         if interpreter == sys.executable:

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

   773         else:

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

   775             env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'

   776             file = __file__

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

   778                 file = file[:-1]

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

   780             raise SystemExit(popen.wait())

   781 

   782     if not args:

   783         print('You must provide a DEST_DIR')

   784         parser.print_help()

   785         sys.exit(2)

   786     if len(args) > 1:

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

   788             ' '.join(args)))

   789         parser.print_help()

   790         sys.exit(2)

   791 

   792     home_dir = args[0]

   793 

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

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

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

   797         sys.exit(3)

   798 

   799     if 'PYTHONHOME' in os.environ:

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

   801         del os.environ['PYTHONHOME']

   802 

   803     if options.relocatable:

   804         make_environment_relocatable(home_dir)

   805         return

   806 

   807     create_environment(home_dir, site_packages=not options.no_site_packages, clear=options.clear,

   808                        unzip_setuptools=options.unzip_setuptools,

   809                        use_distribute=options.use_distribute or majver > 2,

   810                        prompt=options.prompt,

   811                        search_dirs=options.search_dirs,

   812                        never_download=options.never_download)

   813     if 'after_install' in globals():

   814         after_install(options, home_dir)

   815 

   816 def call_subprocess(cmd, show_stdout=True,

   817                     filter_stdout=None, cwd=None,

   818                     raise_on_returncode=True, extra_env=None,

   819                     remove_from_env=None):

   820     cmd_parts = []

   821     for part in cmd:

   822         if len(part) > 45:

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

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

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

   826         cmd_parts.append(part)

   827     cmd_desc = ' '.join(cmd_parts)

   828     if show_stdout:

   829         stdout = None

   830     else:

   831         stdout = subprocess.PIPE

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

   833     if extra_env or remove_from_env:

   834         env = os.environ.copy()

   835         if extra_env:

   836             env.update(extra_env)

   837         if remove_from_env:

   838             for varname in remove_from_env:

   839                 env.pop(varname, None)

   840     else:

   841         env = None

   842     try:

   843         proc = subprocess.Popen(

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

   845             cwd=cwd, env=env)

   846     except Exception:

   847         e = sys.exc_info()[1]

   848         logger.fatal(

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

   850         raise

   851     all_output = []

   852     if stdout is not None:

   853         stdout = proc.stdout

   854         encoding = sys.getdefaultencoding()

   855         while 1:

   856             line = stdout.readline().decode(encoding)

   857             if not line:

   858                 break

   859             line = line.rstrip()

   860             all_output.append(line)

   861             if filter_stdout:

   862                 level = filter_stdout(line)

   863                 if isinstance(level, tuple):

   864                     level, line = level

   865                 logger.log(level, line)

   866                 if not logger.stdout_level_matches(level):

   867                     logger.show_progress()

   868             else:

   869                 logger.info(line)

   870     else:

   871         proc.communicate()

   872     proc.wait()

   873     if proc.returncode:

   874         if raise_on_returncode:

   875             if all_output:

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

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

   878             raise OSError(

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

   880                 % (cmd_desc, proc.returncode))

   881         else:

   882             logger.warn(

   883                 "Command %s had error code %s"

   884                 % (cmd_desc, proc.returncode))

   885 

   886 

   887 def create_environment(home_dir, site_packages=True, clear=False,

   888                        unzip_setuptools=False, use_distribute=False,

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

   890     """

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

   892 

   893     If ``site_packages`` is true (the default) then the global

   894     ``site-packages/`` directory will be on the path.

   895 

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

   897     first be cleared.

   898     """

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

   900 

   901     py_executable = os.path.abspath(install_python(

   902         home_dir, lib_dir, inc_dir, bin_dir,

   903         site_packages=site_packages, clear=clear))

   904 

   905     install_distutils(home_dir)

   906 

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

   908         install_distribute(py_executable, unzip=unzip_setuptools, 

   909                            search_dirs=search_dirs, never_download=never_download)

   910     else:

   911         install_setuptools(py_executable, unzip=unzip_setuptools, 

   912                            search_dirs=search_dirs, never_download=never_download)

   913 

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

   915 

   916     install_activate(home_dir, bin_dir, prompt)

   917 

   918 def path_locations(home_dir):

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

   920     where scripts go, etc)"""

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

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

   923     if sys.platform == 'win32':

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

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

   926         # format):

   927         mkdir(home_dir)

   928         if ' ' in home_dir:

   929             try:

   930                 import win32api

   931             except ImportError:

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

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

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

   935                 sys.exit(3)

   936             home_dir = win32api.GetShortPathName(home_dir)

   937         lib_dir = join(home_dir, 'Lib')

   938         inc_dir = join(home_dir, 'Include')

   939         bin_dir = join(home_dir, 'Scripts')

   940     elif is_jython:

   941         lib_dir = join(home_dir, 'Lib')

   942         inc_dir = join(home_dir, 'Include')

   943         bin_dir = join(home_dir, 'bin')

   944     elif is_pypy:

   945         lib_dir = home_dir

   946         inc_dir = join(home_dir, 'include')

   947         bin_dir = join(home_dir, 'bin')

   948     else:

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

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

   951         bin_dir = join(home_dir, 'bin')

   952     return home_dir, lib_dir, inc_dir, bin_dir

   953 

   954 

   955 def change_prefix(filename, dst_prefix):

   956     prefixes = [sys.prefix]

   957 

   958     if sys.platform == "darwin":

   959         prefixes.extend((

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

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

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

   963 

   964     if hasattr(sys, 'real_prefix'):

   965         prefixes.append(sys.real_prefix)

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

   967     filename = os.path.abspath(filename)

   968     for src_prefix in prefixes:

   969         if filename.startswith(src_prefix):

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

   971             assert relpath[0] == os.sep

   972             relpath = relpath[1:]

   973             return join(dst_prefix, relpath)

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

   975         (filename, prefixes)

   976 

   977 def copy_required_modules(dst_prefix):

   978     import imp

   979     for modname in REQUIRED_MODULES:

   980         if modname in sys.builtin_module_names:

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

   982             continue

   983         try:

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

   985         except ImportError:

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

   987         else:

   988             if f is not None:

   989                 f.close()

   990             dst_filename = change_prefix(filename, dst_prefix)

   991             copyfile(filename, dst_filename)

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

   993                 pyfile = filename[:-1]

   994                 if os.path.exists(pyfile):

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

   996 

   997 

   998 def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear):

   999     """Install just the base environment, no distutils patches etc"""

  1000     if sys.executable.startswith(bin_dir):

  1001         print('Please use the *system* python to run this script')

  1002         return

  1003 

  1004     if clear:

  1005         rmtree(lib_dir)

  1006         ## FIXME: why not delete it?

  1007         ## Maybe it should delete everything with #!/path/to/venv/python in it

  1008         logger.notify('Not deleting %s', bin_dir)

  1009 

  1010     if hasattr(sys, 'real_prefix'):

  1011         logger.notify('Using real prefix %r' % sys.real_prefix)

  1012         prefix = sys.real_prefix

  1013     else:

  1014         prefix = sys.prefix

  1015     mkdir(lib_dir)

  1016     fix_lib64(lib_dir)

  1017     fix_local_scheme(home_dir)

  1018     stdlib_dirs = [os.path.dirname(os.__file__)]

  1019     if sys.platform == 'win32':

  1020         stdlib_dirs.append(join(os.path.dirname(stdlib_dirs[0]), 'DLLs'))

  1021     elif sys.platform == 'darwin':

  1022         stdlib_dirs.append(join(stdlib_dirs[0], 'site-packages'))

  1023     if hasattr(os, 'symlink'):

  1024         logger.info('Symlinking Python bootstrap modules')

  1025     else:

  1026         logger.info('Copying Python bootstrap modules')

  1027     logger.indent += 2

  1028     try:

  1029         # copy required files...

  1030         for stdlib_dir in stdlib_dirs:

  1031             if not os.path.isdir(stdlib_dir):

  1032                 continue

  1033             for fn in os.listdir(stdlib_dir):

  1034                 bn = os.path.splitext(fn)[0]

  1035                 if fn != 'site-packages' and bn in REQUIRED_FILES:

  1036                     copyfile(join(stdlib_dir, fn), join(lib_dir, fn))

  1037         # ...and modules

  1038         copy_required_modules(home_dir)

  1039     finally:

  1040         logger.indent -= 2

  1041     mkdir(join(lib_dir, 'site-packages'))

  1042     import site

  1043     site_filename = site.__file__

  1044     if site_filename.endswith('.pyc'):

  1045         site_filename = site_filename[:-1]

  1046     elif site_filename.endswith('$py.class'):

  1047         site_filename = site_filename.replace('$py.class', '.py')

  1048     site_filename_dst = change_prefix(site_filename, home_dir)

  1049     site_dir = os.path.dirname(site_filename_dst)

  1050     writefile(site_filename_dst, SITE_PY)

  1051     writefile(join(site_dir, 'orig-prefix.txt'), prefix)

  1052     site_packages_filename = join(site_dir, 'no-global-site-packages.txt')

  1053     if not site_packages:

  1054         writefile(site_packages_filename, '')

  1055     else:

  1056         if os.path.exists(site_packages_filename):

  1057             logger.info('Deleting %s' % site_packages_filename)

  1058             os.unlink(site_packages_filename)

  1059 

  1060     if is_pypy or is_win:

  1061         stdinc_dir = join(prefix, 'include')

  1062     else:

  1063         stdinc_dir = join(prefix, 'include', py_version + abiflags)

  1064     if os.path.exists(stdinc_dir):

  1065         copyfile(stdinc_dir, inc_dir)

  1066     else:

  1067         logger.debug('No include dir %s' % stdinc_dir)

  1068 

  1069     # pypy never uses exec_prefix, just ignore it

  1070     if sys.exec_prefix != prefix and not is_pypy:

  1071         if sys.platform == 'win32':

  1072             exec_dir = join(sys.exec_prefix, 'lib')

  1073         elif is_jython:

  1074             exec_dir = join(sys.exec_prefix, 'Lib')

  1075         else:

  1076             exec_dir = join(sys.exec_prefix, 'lib', py_version)

  1077         for fn in os.listdir(exec_dir):

  1078             copyfile(join(exec_dir, fn), join(lib_dir, fn))

  1079 

  1080     if is_jython:

  1081         # Jython has either jython-dev.jar and javalib/ dir, or just

  1082         # jython.jar

  1083         for name in 'jython-dev.jar', 'javalib', 'jython.jar':

  1084             src = join(prefix, name)

  1085             if os.path.exists(src):

  1086                 copyfile(src, join(home_dir, name))

  1087         # XXX: registry should always exist after Jython 2.5rc1

  1088         src = join(prefix, 'registry')

  1089         if os.path.exists(src):

  1090             copyfile(src, join(home_dir, 'registry'), symlink=False)

  1091         copyfile(join(prefix, 'cachedir'), join(home_dir, 'cachedir'),

  1092                  symlink=False)

  1093 

  1094     mkdir(bin_dir)

  1095     py_executable = join(bin_dir, os.path.basename(sys.executable))

  1096     if 'Python.framework' in prefix:

  1097         if re.search(r'/Python(?:-32|-64)*$', py_executable):

  1098             # The name of the python executable is not quite what

  1099             # we want, rename it.

  1100             py_executable = os.path.join(

  1101                     os.path.dirname(py_executable), 'python')

  1102 

  1103     logger.notify('New %s executable in %s', expected_exe, py_executable)

  1104     if sys.executable != py_executable:

  1105         ## FIXME: could I just hard link?

  1106         executable = sys.executable

  1107         if sys.platform == 'cygwin' and os.path.exists(executable + '.exe'):

  1108             # Cygwin misreports sys.executable sometimes

  1109             executable += '.exe'

  1110             py_executable += '.exe'

  1111             logger.info('Executable actually exists in %s' % executable)

  1112         shutil.copyfile(executable, py_executable)

  1113         make_exe(py_executable)

  1114         if sys.platform == 'win32' or sys.platform == 'cygwin':

  1115             pythonw = os.path.join(os.path.dirname(sys.executable), 'pythonw.exe')

  1116             if os.path.exists(pythonw):

  1117                 logger.info('Also created pythonw.exe')

  1118                 shutil.copyfile(pythonw, os.path.join(os.path.dirname(py_executable), 'pythonw.exe'))

  1119         if is_pypy:

  1120             # make a symlink python --> pypy-c

  1121             python_executable = os.path.join(os.path.dirname(py_executable), 'python')

  1122             logger.info('Also created executable %s' % python_executable)

  1123             copyfile(py_executable, python_executable)

  1124 

  1125     if os.path.splitext(os.path.basename(py_executable))[0] != expected_exe:

  1126         secondary_exe = os.path.join(os.path.dirname(py_executable),

  1127                                      expected_exe)

  1128         py_executable_ext = os.path.splitext(py_executable)[1]

  1129         if py_executable_ext == '.exe':

  1130             # python2.4 gives an extension of '.4' :P

  1131             secondary_exe += py_executable_ext

  1132         if os.path.exists(secondary_exe):

  1133             logger.warn('Not overwriting existing %s script %s (you must use %s)'

  1134                         % (expected_exe, secondary_exe, py_executable))

  1135         else:

  1136             logger.notify('Also creating executable in %s' % secondary_exe)