#!/usr/bin/env python

"""Create a "virtual" Python installation"""

import os

import sys

# If we are running in a new interpreter to create a virtualenv,

# we do NOT want paths from our existing location interfering with anything,

# So we remove this file's directory from sys.path - most likely to be

# the previous interpreter's site-packages. Solves #705, #763, #779

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

    for path in sys.path[:]:

        if os.path.realpath(os.path.dirname(__file__)) == os.path.realpath(path):

            sys.path.remove(path)

import base64

import codecs

import optparse

import re

import shutil

import logging

import zlib

import errno

import glob

import distutils.sysconfig

import struct

import subprocess

import pkgutil

import tempfile

import textwrap

from distutils.util import strtobool

from os.path import join

try:

    import ConfigParser

except ImportError:

    import configparser as ConfigParser

__version__ = "15.0.0"

virtualenv_version = __version__  # legacy

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:

    basestring

except NameError:

    basestring = str

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

        try:

            python_core = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE,

                                           "Software\\Python\\PythonCore")

        except WindowsError:

            # No registered Python installations

            return {}

        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:

            try:

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

            except WindowsError:

                continue

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

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)

        REQUIRED_MODULES.extend([

        	'base64', '_dummy_thread', 'hashlib', 'hmac',

        	'imp', 'importlib', 'rlcompleter'

        ])

    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

            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, symlink=True):

    if os.path.isdir(src):

        shutil.copytree(src, dest, symlink)

    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, symlink)

    else:

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

        copyfileordir(src, dest, symlink)

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

    if not os.path.exists(dest):

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

        with open(dest, 'wb') as f:

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

        return

    else:

        with open(dest, 'rb') as f:

            c = f.read()

        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)

            with open(dest, 'wb') as f:

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

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