#!/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.

__version__ = "1.9.1"  # following best practices

virtualenv_version = __version__  # legacy, again

import base64

import sys

import os

import codecs

import optparse

import re

import shutil

import logging

import tempfile

import zlib

import errno

import glob

import distutils.sysconfig

from distutils.util import strtobool

import struct

import subprocess

if sys.version_info < (2, 5):

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

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

    sys.exit(101)

try:

    set

except NameError:

    from sets import Set as set

try:

    basestring

except NameError:

    basestring = str

try:

    import ConfigParser

except ImportError:

    import configparser as ConfigParser

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

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

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

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

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

if is_win:

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

else:

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

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

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', 'tokenize', 'token',

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

                             'reprlib'])

    if minver >= 2:

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

    if minver == 3:

        import sysconfig

        platdir = sysconfig.get_config_var('PLATDIR')

        REQUIRED_FILES.append(platdir)

        # 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",

            "imp",

            "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.ERROR, 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') and not is_win:

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

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

        f = open(dest, 'wb')

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

        f.close()

        return

    else:

        f = open(dest, 'rb')

        c = f.read()

        f.close()

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

            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.encode('utf-8'))

            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 & 0xFFF # 0o7777

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

        os.chmod(fn, newmode)

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

def _find_file(filename, dirs):

    for dir in reversed(dirs):

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

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

            return True, files[0]

    return False, filename

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

                 search_dirs=None, never_download=False):

    if search_dirs is None:

        search_dirs = file_search_dirs()

    if not distribute:

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

        found, egg_path = _find_file(egg_path, search_dirs)

        project_name = 'setuptools'

        bootstrap_script = EZ_SETUP_PY

        tgz_path = None

    else:

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

        # but can be made available by the user)

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

        found, egg_path = _find_file(egg_path, search_dirs)

        project_name = 'distribute'

        if found:

            tgz_path = None

            bootstrap_script = DISTRIBUTE_FROM_EGG_PY

        else:

            # Fall back to sdist

            # NB: egg_path is not None iff tgz_path is None

            # iff bootstrap_script is a generic setup script accepting

            # the standard arguments.

            egg_path = None

            tgz_path = 'distribute-*.tar.gz'

            found, tgz_path = _find_file(tgz_path, search_dirs)

            bootstrap_script = DISTRIBUTE_SETUP_PY

    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 and egg_path:

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

    env = {}

    remove_from_env = ['__PYVENV_LAUNCHER__']

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