#!/usr/bin/env python

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

# fmt: off

import os  # isort:skip

import sys  # isort:skip

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

# fmt: on

import ast

import base64

import codecs

import contextlib

import distutils.spawn

import distutils.sysconfig

import errno

import glob

import logging

import optparse

import os

import re

import shutil

import struct

import subprocess

import sys

import tempfile

import textwrap

import zipfile

import zlib

from distutils.util import strtobool

from os.path import join

try:

    import ConfigParser

except ImportError:

    # noinspection PyPep8Naming

    import configparser as ConfigParser

__version__ = "16.7.9"

virtualenv_version = __version__  # legacy

DEBUG = os.environ.get("_VIRTUALENV_DEBUG", None) == "1"

if sys.version_info < (2, 7):

    print("ERROR: {}".format(sys.exc_info()[1]))

    print("ERROR: this script requires Python 2.7 or greater.")

    sys.exit(101)

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

IS_ZIPAPP = os.path.isfile(HERE)

try:

    # noinspection PyUnresolvedReferences,PyUnboundLocalVariable

    basestring

except NameError:

    basestring = str

VERSION = "{}.{}".format(*sys.version_info)

PY_VERSION = "python{}.{}".format(*sys.version_info)

IS_PYPY = hasattr(sys, "pypy_version_info")

IS_WIN = sys.platform == "win32"

IS_CYGWIN = sys.platform == "cygwin"

IS_DARWIN = sys.platform == "darwin"

ABI_FLAGS = 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"

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:

        # noinspection PyUnresolvedReferences

        import _winreg as winreg

    def get_installed_pythons():

        final_exes = dict()

        # Grab exes from 32-bit registry view

        exes = _get_installed_pythons_for_view("-32", winreg.KEY_WOW64_32KEY)

        # Grab exes from 64-bit registry view

        exes_64 = _get_installed_pythons_for_view("-64", winreg.KEY_WOW64_64KEY)

        # Check if exes are unique

        if set(exes.values()) != set(exes_64.values()):

            exes.update(exes_64)

        # Create dict with all versions found

        for version, bitness in sorted(exes):

            exe = exes[(version, bitness)]

            # Add minor version (X.Y-32 or X.Y-64)

            final_exes[version + bitness] = exe

            # Add minor extensionless version (X.Y); 3.2-64 wins over 3.2-32

            final_exes[version] = exe

            # Add major version (X-32 or X-64)

            final_exes[version[0] + bitness] = exe

            # Add major extensionless version (X); 3.3-32 wins over 3.2-64

            final_exes[version[0]] = exe

        return final_exes

    def _get_installed_pythons_for_view(bitness, view):

        exes = dict()

        # If both system and current user installations are found for a

        # particular Python version, the current user one is used

        for key in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER):

            try:

                python_core = winreg.OpenKey(key, "Software\\Python\\PythonCore", 0, view | winreg.KEY_READ)

            except WindowsError:

                # No registered Python installations

                continue

            i = 0

            while True:

                try:

                    version = winreg.EnumKey(python_core, i)

                    i += 1

                    try:

                        at_path = winreg.QueryValue(python_core, "{}\\InstallPath".format(version))

                    except WindowsError:

                        continue

                    # Remove bitness from version

                    if version.endswith(bitness):

                        version = version[: -len(bitness)]

                    exes[(version, bitness)] = join(at_path, "python.exe")

                except WindowsError:

                    break

            winreg.CloseKey(python_core)

        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"]

MAJOR, MINOR = sys.version_info[:2]

if MAJOR == 2:

    if MINOR >= 6:

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

    if MINOR >= 7:

        REQUIRED_MODULES.extend(["_weakrefset"])

elif MAJOR == 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 MINOR >= 2:

        REQUIRED_FILES[-1] = "config-{}".format(MAJOR)

    if MINOR >= 3:

        import sysconfig

        platform_dir = sysconfig.get_config_var("PLATDIR")

        REQUIRED_FILES.append(platform_dir)

        REQUIRED_MODULES.extend(["base64", "_dummy_thread", "hashlib", "hmac", "imp", "importlib", "rlcompleter"])

    if MINOR >= 4:

        REQUIRED_MODULES.extend(["operator", "_collections_abc", "_bootlocale"])

    if MINOR >= 6:

        REQUIRED_MODULES.extend(["enum"])

if IS_PYPY:

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

    # during the bootstrap

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

    if MAJOR == 3:

        # _functools is needed to import locale during stdio initialization and

        # needs to be copied on PyPy because it's not built in

        REQUIRED_MODULES.append("_functools")

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

                    print("")

                    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}".format(

            msg, self.in_progress

        )

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

            print(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

                print("...{}{}".format(self.in_progress, msg))

                sys.stdout.flush()

            else:

                print(msg)

                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:

            print(".")

            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

    @staticmethod

    def level_matches(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]

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

    if not os.path.exists(at_path):

        logger.info("Creating %s", at_path)

        os.makedirs(at_path)

    else:

        logger.info("Directory %s already exists", at_path)

def copy_file_or_folder(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 symlink and hasattr(os, "symlink") and not IS_WIN:

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

        try:

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

        except (OSError, NotImplementedError):

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

            copy_file_or_folder(src, dest, symlink)

    else:

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

        copy_file_or_folder(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 rm_tree(folder):

    if os.path.exists(folder):

        logger.notify("Deleting tree %s", folder)

        shutil.rmtree(folder)

    else:

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

def make_exe(fn):

    if hasattr(os, "chmod"):

        old_mode = os.stat(fn).st_mode & 0xFFF  # 0o7777

        new_mode = (old_mode | 0x16D) & 0xFFF  # 0o555, 0o7777

        os.chmod(fn, new_mode)

        logger.info("Changed mode of %s to %s", fn, oct(new_mode))

def _find_file(filename, folders):

    for folder in reversed(folders):

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

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

            return True, files[0]

    return False, filename

@contextlib.contextmanager

def virtualenv_support_dirs():

    """Context manager yielding either [virtualenv_support_dir] or []"""

    # normal filesystem installation

    if os.path.isdir(join(HERE, "virtualenv_support")):

        yield [join(HERE, "virtualenv_support")]

    elif IS_ZIPAPP:

        tmpdir = tempfile.mkdtemp()

        try:

            with zipfile.ZipFile(HERE) as zipf:

                for member in zipf.namelist():

                    if os.path.dirname(member) == "virtualenv_support":

                        zipf.extract(member, tmpdir)

            yield [join(tmpdir, "virtualenv_support")]

        finally:

            shutil.rmtree(tmpdir)

    # probably a bootstrap script

    elif os.path.splitext(os.path.dirname(__file__))[0] != "virtualenv":

        try:

            # noinspection PyUnresolvedReferences

            import virtualenv

        except ImportError:

            yield []

        else:

            yield [join(os.path.dirname(virtualenv.__file__), "virtualenv_support")]

    # we tried!