#!/usr/bin/env python2.6

## WARNING: This file is generated

#!/usr/bin/env python

"""Create a "virtual" Python installation

"""

virtualenv_version = "1.4.9"

import sys

import os

import optparse

import re

import shutil

import logging

import tempfile

import distutils.sysconfig

try:

    import subprocess

except ImportError, e:

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

        print 'ERROR: %s' % e

        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

join = os.path.join

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

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

expected_exe = is_jython and 'jython' or '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',

                    'lib-dynload', 'config', 'zlib']

if sys.version_info[:2] >= (2, 6):

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

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

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

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 or 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)

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 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 symlink and hasattr(os, 'symlink'):

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

        os.symlink(os.path.abspath(src), dest)

    else:

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

        if os.path.isdir(src):

            shutil.copytree(src, dest, True)

        else:

            shutil.copy2(src, dest)

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

    if not os.path.exists(dest):

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

        f = open(dest, 'wb')

        f.write(content)

        f.close()

        return

    else:

        f = open(dest, 'rb')

        c = f.read()

        f.close()

        if c != content:

            if not overwrite:

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

                return

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

            f = open(dest, 'wb')

            f.write(content)

            f.close()

        else:

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

def rmtree(dir):

    if os.path.exists(dir):

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

        shutil.rmtree(dir)

    else:

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

def make_exe(fn):

    if hasattr(os, 'chmod'):

        oldmode = os.stat(fn).st_mode & 07777

        newmode = (oldmode | 0555) & 07777

        os.chmod(fn, newmode)

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

def _find_file(filename, dirs):

    for dir in dirs:

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

            return join(dir, filename)

    return filename

def _install_req(py_executable, unzip=False, distribute=False):

    if not distribute:

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

        project_name = 'setuptools'

        bootstrap_script = EZ_SETUP_PY

        source = None

    else:

        setup_fn = None

        source = 'distribute-0.6.8.tar.gz'

        project_name = 'distribute'

        bootstrap_script = DISTRIBUTE_SETUP_PY

        try:

            # check if the global Python has distribute installed or plain

            # setuptools

            import pkg_resources

            if not hasattr(pkg_resources, '_distribute'):

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

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

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

                              "the virtualenv.")

        except ImportError:

            pass

    search_dirs = file_search_dirs()

    if setup_fn is not None:

        setup_fn = _find_file(setup_fn, search_dirs)

    if source is not None:

        source = _find_file(source, search_dirs)

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

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

        # argument with newlines

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

        os.write(fd, bootstrap_script)

        os.close(fd)

        cmd = [py_executable, ez_setup]

    else:

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

    if unzip:

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

    env = {}

    if logger.stdout_level_matches(logger.DEBUG):

        cmd.append('-v')

    old_chdir = os.getcwd()

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

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

        cmd.append(setup_fn)

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

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

        else:

            env['PYTHONPATH'] = setup_fn

    else:

        # the source is found, let's chdir

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

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

        else:

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

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

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

    logger.indent += 2

    cwd = None

    if project_name == 'distribute':

        env['DONT_PATCH_SETUPTOOLS'] = 'true'

    def _filter_ez_setup(line):

        return filter_ez_setup(line, project_name)

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

        cwd = tempfile.mkdtemp()

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

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

            # tarball to a temp dir

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

            shutil.copy(source, target)

    try:

        call_subprocess(cmd, show_stdout=False,

                        filter_stdout=_filter_ez_setup,

                        extra_env=env,

                        cwd=cwd)

    finally:

        logger.indent -= 2

        logger.end_progress()

        if os.getcwd() != old_chdir:

            os.chdir(old_chdir)

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

            os.remove(ez_setup)

def file_search_dirs():

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

    dirs = ['.', here,

            join(here, 'virtualenv_support')]

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

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

        try:

            import virtualenv

        except ImportError:

            pass

        else:

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

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

def install_setuptools(py_executable, unzip=False):

    _install_req(py_executable, unzip)

def install_distribute(py_executable, unzip=False):

    _install_req(py_executable, unzip, distribute=True)

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

def install_pip(py_executable):

    filenames = []

    for dir in file_search_dirs():

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

                          if _pip_re.search(fn)])

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

    filenames.sort()

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

    if not filenames:

        filename = 'pip'

    else:

        filename = filenames[-1]

    easy_install_script = 'easy_install'