#!/usr/bin/env python

"""Create a "virtual" Python installation

"""

__version__ = "1.11.6"

virtualenv_version = __version__  # legacy

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

import tarfile

if sys.version_info < (2, 6):

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

    print('ERROR: this script requires Python 2.6 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'

# Return a mapping of version -> Python executable

# Only provided for Windows, where the information in the registry is used

if not is_win:

    def get_installed_pythons():

        return {}

else:

    try:

        import winreg

    except ImportError:

        import _winreg as winreg

    def get_installed_pythons():

        python_core = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE,

                "Software\\Python\\PythonCore")

        i = 0

        versions = []

        while True:

            try:

                versions.append(winreg.EnumKey(python_core, i))

                i = i + 1

            except WindowsError:

                break

        exes = dict()

        for ver in versions:

            path = winreg.QueryValue(python_core, "%s\\InstallPath" % ver)

            exes[ver] = join(path, "python.exe")

        winreg.CloseKey(python_core)

        # Add the major versions

        # Sort the keys, then repeatedly update the major version entry

        # Last executable (i.e., highest version) wins with this approach

        for ver in sorted(exes):

            exes[ver[0]] = exes[ver]

        return exes

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 minver >= 4:

        REQUIRED_MODULES.extend([

            'operator',

            '_collections_abc',

            '_bootlocale',

        ])

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