#!/usr/bin/env python2.6

## WARNING: This file is generated

#!/usr/bin/env python

"""Create a "virtual" Python installation

"""

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

# and docs/conf.py as well.

virtualenv_version = "1.6.4"

import base64

import sys

import os

import optparse

import re

import shutil

import logging

import tempfile

import zlib

import errno

import distutils.sysconfig

try:

    import subprocess

except ImportError:

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

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

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

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

        sys.exit(101)

    else:

        raise

try:

    set

except NameError:

    from sets import Set as set

try:

    basestring

except NameError:

    basestring = str

join = os.path.join

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

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

is_pypy = hasattr(sys, 'pypy_version_info')

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

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

if is_pypy:

    expected_exe = 'pypy'

elif is_jython:

    expected_exe = 'jython'

else:

    expected_exe = 'python'

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

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

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

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

                    'zlib']

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

majver, minver = sys.version_info[:2]

if majver == 2:

    if minver >= 6:

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

    if minver >= 7:

        REQUIRED_MODULES.extend(['_weakrefset'])

    if minver <= 3:

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

elif majver == 3:

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

    # for different versions.

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

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

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

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

    if minver >= 2:

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

    if minver == 3:

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

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

        # added as 3.3 development continues.

        REQUIRED_MODULES.extend([

            #"aifc",

            #"antigravity",

            #"argparse",

            #"ast",

            #"asynchat",

            #"asyncore",

            "base64",

            #"bdb",

            #"binhex",

            "bisect",

            #"calendar",

            #"cgi",

            #"cgitb",

            #"chunk",

            #"cmd",

            #"codeop",

            #"code",

            #"colorsys",

            #"_compat_pickle",

            #"compileall",

            #"concurrent",

            #"configparser",

            #"contextlib",

            #"cProfile",

            #"crypt",

            #"csv",

            #"ctypes",

            #"curses",

            #"datetime",

            #"dbm",

            #"decimal",

            #"difflib",

            #"dis",

            #"doctest",

            #"dummy_threading",

            "_dummy_thread",

            #"email",

            #"filecmp",

            #"fileinput",

            #"formatter",

            #"fractions",

            #"ftplib",

            #"functools",

            #"getopt",

            #"getpass",

            #"gettext",

            #"glob",

            #"gzip",

            "hashlib",

            "heapq",

            "hmac",

            #"html",

            #"http",

            #"idlelib",

            #"imaplib",

            #"imghdr",

            #"importlib",

            #"inspect",

            #"json",

            #"lib2to3",

            #"logging",

            #"macpath",

            #"macurl2path",

            #"mailbox",

            #"mailcap",

            #"_markupbase",

            #"mimetypes",

            #"modulefinder",

            #"multiprocessing",

            #"netrc",

            #"nntplib",

            #"nturl2path",

            #"numbers",

            #"opcode",

            #"optparse",

            #"os2emxpath",

            #"pdb",

            #"pickle",

            #"pickletools",

            #"pipes",

            #"pkgutil",

            #"platform",

            #"plat-linux2",

            #"plistlib",

            #"poplib",

            #"pprint",

            #"profile",

            #"pstats",

            #"pty",

            #"pyclbr",

            #"py_compile",

            #"pydoc_data",

            #"pydoc",

            #"_pyio",

            #"queue",

            #"quopri",

            "reprlib",

            "rlcompleter",

            #"runpy",

            #"sched",

            #"shelve",

            #"shlex",

            #"smtpd",

            #"smtplib",

            #"sndhdr",

            #"socket",

            #"socketserver",

            #"sqlite3",

            #"ssl",

            #"stringprep",

            #"string",

            #"_strptime",

            #"subprocess",

            #"sunau",

            #"symbol",

            #"symtable",

            #"sysconfig",

            #"tabnanny",

            #"telnetlib",

            #"test",

            #"textwrap",

            #"this",

            #"_threading_local",

            #"threading",

            #"timeit",

            #"tkinter",

            #"tokenize",

            #"token",

            #"traceback",

            #"trace",

            #"tty",

            #"turtledemo",

            #"turtle",

            #"unittest",

            #"urllib",

            #"uuid",

            #"uu",

            #"wave",

            "weakref",

            #"webbrowser",

            #"wsgiref",

            #"xdrlib",

            #"xml",

            #"xmlrpc",

            #"zipfile",

        ])

if is_pypy:

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

    # during the bootstrap

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

class Logger(object):

    """

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

    levels, to avoid some redundancy of displayed information.

    """

    DEBUG = logging.DEBUG

    INFO = logging.INFO

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

    WARN = WARNING = logging.WARN

    ERROR = logging.ERROR

    FATAL = logging.FATAL

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

    def __init__(self, consumers):

        self.consumers = consumers

        self.indent = 0

        self.in_progress = None

        self.in_progress_hanging = False

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

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

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

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

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

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

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

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

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

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

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

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

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

        if args:

            if kw:

                raise TypeError(

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

        args = args or kw

        rendered = None

        for consumer_level, consumer in self.consumers:

            if self.level_matches(level, consumer_level):

                if (self.in_progress_hanging

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

                    self.in_progress_hanging = False

                    sys.stdout.write('\n')

                    sys.stdout.flush()

                if rendered is None:

                    if args:

                        rendered = msg % args

                    else:

                        rendered = msg

                    rendered = ' '*self.indent + rendered

                if hasattr(consumer, 'write'):

                    consumer.write(rendered+'\n')

                else:

                    consumer(rendered)

    def start_progress(self, msg):

        assert not self.in_progress, (

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

            % (msg, self.in_progress))

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

            sys.stdout.write(msg)

            sys.stdout.flush()

            self.in_progress_hanging = True

        else:

            self.in_progress_hanging = False

        self.in_progress = msg

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

        assert self.in_progress, (

            "Tried to end_progress without start_progress")

        if self.stdout_level_matches(self.NOTIFY):

            if not self.in_progress_hanging:

                # Some message has been printed out since start_progress

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

                sys.stdout.flush()

            else:

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

                sys.stdout.flush()

        self.in_progress = None

        self.in_progress_hanging = False

    def show_progress(self):

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

        shown, write out another '.'"""

        if self.in_progress_hanging:

            sys.stdout.write('.')

            sys.stdout.flush()

    def stdout_level_matches(self, level):

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

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

    def _stdout_level(self):

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

        for level, consumer in self.consumers:

            if consumer is sys.stdout:

                return level

        return self.FATAL

    def level_matches(self, level, consumer_level):

        """

        >>> l = Logger([])

        >>> l.level_matches(3, 4)

        False

        >>> l.level_matches(3, 2)

        True

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

        False

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

        True

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

        True

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

        False

        """

        if isinstance(level, slice):

            start, stop = level.start, level.stop

            if start is not None and start > consumer_level:

                return False

            if stop is not None and stop <= consumer_level:

                return False

            return True

        else:

            return level >= consumer_level

    #@classmethod

    def level_for_integer(cls, level):

        levels = cls.LEVELS

        if level < 0:

            return levels[0]

        if level >= len(levels):

            return levels[-1]

        return levels[level]

    level_for_integer = classmethod(level_for_integer)

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

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

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

def mkdir(path):

    if not os.path.exists(path):

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

        os.makedirs(path)

    else:

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

def copyfileordir(src, dest):

    if os.path.isdir(src):

        shutil.copytree(src, dest, True)

    else:

        shutil.copy2(src, dest)

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

    if not os.path.exists(src):

        # Some bad symlink in the src

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

        return

    if os.path.exists(dest):

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

        return

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

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

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

    if not os.path.islink(src):

        srcpath = os.path.abspath(src)

    else:

        srcpath = os.readlink(src)

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

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

        try:

            os.symlink(srcpath, dest)

        except (OSError, NotImplementedError):

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

            copyfileordir(src, dest)

    else:

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

        copyfileordir(src, dest)

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

    if not os.path.exists(dest):