#############################################################################

#

# Copyright (c) 2005 Zope Corporation and Contributors.

# All Rights Reserved.

#

# This software is subject to the provisions of the Zope Public License,

# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.

# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED

# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS

# FOR A PARTICULAR PURPOSE.

#

##############################################################################

"""Python easy_install API

This module provides a high-level Python API for installing packages.

It doesn't install scripts.  It uses setuptools and requires it to be

installed.

"""

import distutils.errors

import fnmatch

import glob

import logging

import os

import pkg_resources

import py_compile

import re

import setuptools.archive_util

import setuptools.command.setopt

import setuptools.package_index

import shutil

import subprocess

import sys

import tempfile

import warnings

import zc.buildout

import zipimport

_oprp = getattr(os.path, 'realpath', lambda path: path)

def realpath(path):

    return os.path.normcase(os.path.abspath(_oprp(path)))

default_index_url = os.environ.get(

    'buildout-testing-index-url',

    'http://pypi.python.org/simple',

    )

logger = logging.getLogger('zc.buildout.easy_install')

url_match = re.compile('[a-z0-9+.-]+://').match

is_win32 = sys.platform == 'win32'

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

is_distribute = (

    pkg_resources.Requirement.parse('setuptools').key=='distribute')

BROKEN_DASH_S_WARNING = (

    'Buildout has been asked to exclude or limit site-packages so that '

    'builds can be repeatable when using a system Python.  However, '

    'the chosen Python executable has a broken implementation of -S (see '

    'https://bugs.launchpad.net/virtualenv/+bug/572545 for an example '

    "problem) and this breaks buildout's ability to isolate site-packages.  "

    "If the executable already has a clean site-packages (e.g., "

    "using virtualenv's ``--no-site-packages`` option) you may be getting "

    'equivalent repeatability.  To silence this warning, use the -s argument '

    'to the buildout script.  Alternatively, use a Python executable with a '

    'working -S (such as a standard Python binary).')

if is_jython:

    import java.lang.System

    jython_os_name = (java.lang.System.getProperties()['os.name']).lower()

setuptools_loc = pkg_resources.working_set.find(

    pkg_resources.Requirement.parse('setuptools')

    ).location

# Include buildout and setuptools eggs in paths.  We prevent dupes just to

# keep from duplicating any log messages about them.

buildout_loc = pkg_resources.working_set.find(

    pkg_resources.Requirement.parse('zc.buildout')).location

buildout_and_setuptools_path = [setuptools_loc]

if os.path.normpath(setuptools_loc) != os.path.normpath(buildout_loc):

    buildout_and_setuptools_path.append(buildout_loc)

def _has_broken_dash_S(executable):

    """Detect https://bugs.launchpad.net/virtualenv/+bug/572545 ."""

    # The first attempt here was to simply have the executable attempt to import

    # ConfigParser and return the return code. That worked except for tests on

    # Windows, where the return code was wrong for the fake Python executable

    # generated by the virtualenv.txt test, apparently because setuptools' .exe

    # file does not pass the -script.py's returncode back properly, at least in

    # some circumstances. Therefore...print statements.

    stdout, stderr = subprocess.Popen(

        [executable, '-Sc',

         'try:\n'

         '    import ConfigParser\n'

         'except ImportError:\n'

         '    print 1\n'

         'else:\n'

         '    print 0\n'],

        stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()

    return bool(int(stdout.strip()))

def _get_system_paths(executable):

    """Return lists of standard lib and site paths for executable.

    """

    # We want to get a list of the site packages, which is not easy.

    # The canonical way to do this is to use

    # distutils.sysconfig.get_python_lib(), but that only returns a

    # single path, which does not reflect reality for many system

    # Pythons, which have multiple additions.  Instead, we start Python

    # with -S, which does not import site.py and set up the extra paths

    # like site-packages or (Ubuntu/Debian) dist-packages and

    # python-support. We then compare that sys.path with the normal one

    # (minus user packages if this is Python 2.6, because we don't

    # support those (yet?).  The set of the normal one minus the set of

    # the ones in ``python -S`` is the set of packages that are

    # effectively site-packages.

    #

    # The given executable might not be the current executable, so it is

    # appropriate to do another subprocess to figure out what the

    # additional site-package paths are. Moreover, even if this

    # executable *is* the current executable, this code might be run in

    # the context of code that has manipulated the sys.path--for

    # instance, to add local zc.buildout or setuptools eggs.

    def get_sys_path(*args, **kwargs):

        cmd = [executable]

        cmd.extend(args)

        cmd.extend([

            "-c", "import sys, os;"

            "print repr([os.path.normpath(p) for p in sys.path if p])"])

        # Windows needs some (as yet to be determined) part of the real env.

        env = os.environ.copy()

        # We need to make sure that PYTHONPATH, which will often be set

        # to include a custom buildout-generated site.py, is not set, or

        # else we will not get an accurate sys.path for the executable.

        env.pop('PYTHONPATH', None)

        env.update(kwargs)

        _proc = subprocess.Popen(

            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)

        stdout, stderr = _proc.communicate();

        if _proc.returncode:

            raise RuntimeError(

                'error trying to get system packages:\n%s' % (stderr,))

        res = eval(stdout.strip())

        try:

            res.remove('.')

        except ValueError:

            pass

        return res

    stdlib = get_sys_path('-S') # stdlib only

    no_user_paths = get_sys_path(PYTHONNOUSERSITE='x')

    site_paths = [p for p in no_user_paths if p not in stdlib]

    return (stdlib, site_paths)

def _get_version_info(executable):

    cmd = [executable, '-Sc',

           'import sys; print(repr(tuple(x for x in sys.version_info)))']

    _proc = subprocess.Popen(

        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

    stdout, stderr = _proc.communicate();

    if _proc.returncode:

        raise RuntimeError(

            'error trying to get system packages:\n%s' % (stderr,))

    return eval(stdout.strip())

class IncompatibleVersionError(zc.buildout.UserError):

    """A specified version is incompatible with a given requirement.

    """

_versions = {sys.executable: '%d.%d' % sys.version_info[:2]}

def _get_version(executable):

    try:

        return _versions[executable]

    except KeyError:

        cmd = _safe_arg(executable) + ' -V'

        p = subprocess.Popen(cmd,

                             shell=True,

                             stdin=subprocess.PIPE,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.STDOUT,

                             close_fds=not is_win32)

        i, o = (p.stdin, p.stdout)

        i.close()

        version = o.read().strip()

        o.close()

        pystring, version = version.split()

        assert pystring == 'Python'

        version = re.match('(\d[.]\d)([.].*\d)?$', version).group(1)

        _versions[executable] = version

        return version

FILE_SCHEME = re.compile('file://', re.I).match

class AllowHostsPackageIndex(setuptools.package_index.PackageIndex):

    """Will allow urls that are local to the system.

    No matter what is allow_hosts.

    """

    def url_ok(self, url, fatal=False):

        if FILE_SCHEME(url):

            return True

        return setuptools.package_index.PackageIndex.url_ok(self, url, False)

_indexes = {}

def _get_index(executable, index_url, find_links, allow_hosts=('*',),

               path=None):

    # If path is None, the index will use sys.path.  If you provide an empty

    # path ([]), it will complain uselessly about missing index pages for

    # packages found in the paths that you expect to use.  Therefore, this path

    # is always the same as the _env path in the Installer.

    key = executable, index_url, tuple(find_links)

    index = _indexes.get(key)

    if index is not None:

        return index

    if index_url is None:

        index_url = default_index_url

    index = AllowHostsPackageIndex(

        index_url, hosts=allow_hosts, search_path=path,

        python=_get_version(executable)

        )

    if find_links:

        index.add_find_links(find_links)

    _indexes[key] = index

    return index

clear_index_cache = _indexes.clear

if is_win32:

    # work around spawn lamosity on windows

    # XXX need safe quoting (see the subprocess.list2cmdline) and test

    def _safe_arg(arg):

        return '"%s"' % arg

else:

    _safe_arg = str

# The following string is used to run easy_install in

# Installer._call_easy_install.  It is usually started with python -S

# (that is, don't import site at start).  That flag, and all of the code

# in this snippet above the last two lines, exist to work around a

# relatively rare problem.  If

#

# - your buildout configuration is trying to install a package that is within

#   a namespace package, and

#

# - you use a Python that has a different version of this package

#   installed in in its site-packages using

#   --single-version-externally-managed (that is, using the mechanism

#   sometimes used by system packagers:

#   http://peak.telecommunity.com/DevCenter/setuptools#install-command ), and

#

# - the new package tries to do sys.path tricks in the setup.py to get a

#   __version__,

#

# then the older package will be loaded first, making the setup version

# the wrong number. While very arguably packages simply shouldn't do

# the sys.path tricks, some do, and we don't want buildout to fall over

# when they do.

#

# The namespace packages installed in site-packages with

# --single-version-externally-managed use a mechanism that cause them to

# be processed when site.py is imported  (see

# http://mail.python.org/pipermail/distutils-sig/2009-May/011730.html

# for another description of the problem).  Simply starting Python with

# -S addresses the problem in Python 2.4 and 2.5, but Python 2.6's

# distutils imports a value from the site module, so we unfortunately

# have to do more drastic surgery in the _easy_install_preface code below.

#

# Here's an example of the .pth files created by setuptools when using that

# flag:

#

# import sys,new,os;

# p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('<NAMESPACE>',));

# ie = os.path.exists(os.path.join(p,'__init__.py'));

# m = not ie and sys.modules.setdefault('<NAMESPACE>',new.module('<NAMESPACE>'));

# mp = (m or []) and m.__dict__.setdefault('__path__',[]);

# (p not in mp) and mp.append(p)

#

# The code, below, then, runs under -S, indicating that site.py should

# not be loaded initially.  It gets the initial sys.path under these

# circumstances, and then imports site (because Python 2.6's distutils

# will want it, as mentioned above). It then reinstates the old sys.path

# value. Then it removes namespace packages (created by the setuptools

# code above) from sys.modules.  It identifies namespace packages by

# iterating over every loaded module.  It first looks if there is a

# __path__, so it is a package; and then it sees if that __path__ does

# not have an __init__.py.  (Note that PEP 382,

# http://www.python.org/dev/peps/pep-0382, makes it possible to have a

# namespace package that has an __init__.py, but also should make it

# unnecessary for site.py to preprocess these packages, so it should be

# fine, as far as can be guessed as of this writing.)  Finally, it

# imports easy_install and runs it.

_easy_install_preface = '''\

import sys,os;\

p = sys.path[:];\

import site;\

sys.path[:] = p;\

[sys.modules.pop(k) for k, v in sys.modules.items()\

 if hasattr(v, '__path__') and len(v.__path__)==1 and\

 not os.path.exists(os.path.join(v.__path__[0],'__init__.py'))];'''

_easy_install_cmd = (

    'from setuptools.command.easy_install import main;main()')

class Installer:

    _versions = {}

    _download_cache = None

    _install_from_cache = False

    _prefer_final = True

    _use_dependency_links = True

    _allow_picked_versions = True

    _always_unzip = False

    _include_site_packages = True

    _allowed_eggs_from_site_packages = ('*',)

    def __init__(self,

                 dest=None,

                 links=(),

                 index=None,

                 executable=sys.executable,

                 always_unzip=None,

                 path=None,

                 newest=True,

                 versions=None,

                 use_dependency_links=None,

                 allow_hosts=('*',),

                 include_site_packages=None,

                 allowed_eggs_from_site_packages=None,

                 prefer_final=None,

                 ):

        self._dest = dest

        self._allow_hosts = allow_hosts

        if self._install_from_cache:

            if not self._download_cache:

                raise ValueError("install_from_cache set to true with no"

                                 " download cache")

            links = ()

            index = 'file://' + self._download_cache

        if use_dependency_links is not None:

            self._use_dependency_links = use_dependency_links

        if prefer_final is not None:

            self._prefer_final = prefer_final

        self._links = links = list(_fix_file_links(links))

        if self._download_cache and (self._download_cache not in links):

            links.insert(0, self._download_cache)

        self._index_url = index

        self._executable = executable

        self._has_broken_dash_S = _has_broken_dash_S(self._executable)

        if always_unzip is not None:

            self._always_unzip = always_unzip

        path = (path and path[:] or [])

        if include_site_packages is not None:

            self._include_site_packages = include_site_packages

        if allowed_eggs_from_site_packages is not None:

            self._allowed_eggs_from_site_packages = tuple(

                allowed_eggs_from_site_packages)

        if self._has_broken_dash_S:

            if (not self._include_site_packages or

                self._allowed_eggs_from_site_packages != ('*',)):

                # We can't do this if the executable has a broken -S.

                warnings.warn(BROKEN_DASH_S_WARNING)

                self._include_site_packages = True

                self._allowed_eggs_from_site_packages = ('*',)

            self._easy_install_cmd = _easy_install_cmd

        else:

            self._easy_install_cmd = _easy_install_preface + _easy_install_cmd

        self._easy_install_cmd = _safe_arg(self._easy_install_cmd)

        stdlib, self._site_packages = _get_system_paths(executable)

        version_info = _get_version_info(executable)

        if version_info == sys.version_info:

            # Maybe we can add the buildout and setuptools path.  If we

            # are including site_packages, we only have to include the extra

            # bits here, so we don't duplicate.  On the other hand, if we

            # are not including site_packages, we only want to include the

            # parts that are not in site_packages, so the code is the same.

            path.extend(

                set(buildout_and_setuptools_path).difference(

                    self._site_packages))

        if self._include_site_packages:

            path.extend(self._site_packages)

        if dest is not None and dest not in path:

            path.insert(0, dest)

        self._path = path

        if self._dest is None:

            newest = False

        self._newest = newest

        self._env = pkg_resources.Environment(path,

                                              python=_get_version(executable))

        self._index = _get_index(executable, index, links, self._allow_hosts,

                                 self._path)

        if versions is not None:

            self._versions = versions

    _allowed_eggs_from_site_packages_regex = None

    def allow_site_package_egg(self, name):

        if (not self._include_site_packages or

            not self._allowed_eggs_from_site_packages):

            # If the answer is a blanket "no," perform a shortcut.

            return False

        if self._allowed_eggs_from_site_packages_regex is None:

            pattern = '(%s)' % (

                '|'.join(

                    fnmatch.translate(name)

                    for name in self._allowed_eggs_from_site_packages),

                )

            self._allowed_eggs_from_site_packages_regex = re.compile(pattern)

        return bool(self._allowed_eggs_from_site_packages_regex.match(name))

    def _satisfied(self, req, source=None):

        # We get all distributions that match the given requirement.  If we are

        # not supposed to include site-packages for the given egg, we also

        # filter those out. Even if include_site_packages is False and so we

        # have excluded site packages from the _env's paths (see

        # Installer.__init__), we need to do the filtering here because an

        # .egg-link, such as one for setuptools or zc.buildout installed by

        # zc.buildout.buildout.Buildout.bootstrap, can indirectly include a

        # path in our _site_packages.

        dists = [dist for dist in self._env[req.project_name] if (

                    dist in req and (

                        dist.location not in self._site_packages or

                        self.allow_site_package_egg(dist.project_name))

                    )

                ]

        if not dists:

            logger.debug('We have no distributions for %s that satisfies %r.',

                         req.project_name, str(req))

            return None, self._obtain(req, source)

        # Note that dists are sorted from best to worst, as promised by

        # env.__getitem__

        for dist in dists:

            if (dist.precedence == pkg_resources.DEVELOP_DIST and

                dist.location not in self._site_packages):

                # System eggs are sometimes installed as develop eggs.

                # Those are not the kind of develop eggs we are looking for

                # here: we want ones that the buildout itself has locally as

                # develop eggs.

                logger.debug('We have a develop egg: %s', dist)

                return dist, None

        # Special common case, we have a specification for a single version:

        specs = req.specs

        if len(specs) == 1 and specs[0][0] == '==':

            logger.debug('We have the distribution that satisfies %r.',

                         str(req))

            return dists[0], None

        if self._prefer_final:

            fdists = [dist for dist in dists

                      if _final_version(dist.parsed_version)

                      ]

            if fdists:

                # There are final dists, so only use those

                dists = fdists

        if not self._newest:

            # We don't need the newest, so we'll use the newest one we

            # find, which is the first returned by

            # Environment.__getitem__.

            return dists[0], None

        best_we_have = dists[0] # Because dists are sorted from best to worst

        # We have some installed distros.  There might, theoretically, be

        # newer ones.  Let's find out which ones are available and see if

        # any are newer.  We only do this if we're willing to install

        # something, which is only true if dest is not None:

        if self._dest is not None:

            best_available = self._obtain(req, source)

        else:

            best_available = None

        if best_available is None:

            # That's a bit odd.  There aren't any distros available.

            # We should use the best one we have that meets the requirement.

            logger.debug(

                'There are no distros available that meet %r.\n'

                'Using our best, %s.',

                str(req), best_available)

            return best_we_have, None

        if self._prefer_final:

            if _final_version(best_available.parsed_version):

                if _final_version(best_we_have.parsed_version):

                    if (best_we_have.parsed_version

                        <

                        best_available.parsed_version

                        ):

                        return None, best_available

                else:

                    return None, best_available

            else:

                if (not _final_version(best_we_have.parsed_version)

                    and

                    (best_we_have.parsed_version

                     <

                     best_available.parsed_version

                     )

                    ):

                    return None, best_available

        else:

            if (best_we_have.parsed_version

                <

                best_available.parsed_version

                ):

                return None, best_available

        logger.debug(

            'We have the best distribution that satisfies %r.',

            str(req))

        return best_we_have, None

    def _load_dist(self, dist):

        dists = pkg_resources.Environment(