#!/usr/bin/env python

import sys

import os

import errno

import stat

import optparse

import pkg_resources

import urllib2

import urllib

import mimetypes

import zipfile

import tarfile

import tempfile

import subprocess

import posixpath

import re

import shutil

import fnmatch

import operator

import copy

try:

    from hashlib import md5

except ImportError:

    import md5 as md5_module

    md5 = md5_module.new

import urlparse

from email.FeedParser import FeedParser

import traceback

from cStringIO import StringIO

import socket

from Queue import Queue

from Queue import Empty as QueueEmpty

import threading

import httplib

import time

import logging

import ConfigParser

from distutils.util import strtobool

from distutils import sysconfig

class InstallationError(Exception):

    """General exception during installation"""

class UninstallationError(Exception):

    """General exception during uninstallation"""

class DistributionNotFound(InstallationError):

    """Raised when a distribution cannot be found to satisfy a requirement"""

class BadCommand(Exception):

    """Raised when virtualenv or a command is not found"""

try:

    any

except NameError:

    def any(seq):

        for item in seq:

            if item:

                return True

        return False

if getattr(sys, 'real_prefix', None):

    ## FIXME: is build/ a good name?

    build_prefix = os.path.join(sys.prefix, 'build')

    src_prefix = os.path.join(sys.prefix, 'src')

else:

    ## FIXME: this isn't a very good default

    build_prefix = os.path.join(os.getcwd(), 'build')

    src_prefix = os.path.join(os.getcwd(), 'src')

# FIXME doesn't account for venv linked to global site-packages

site_packages = sysconfig.get_python_lib()

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

if sys.platform == 'win32':

    bin_py = os.path.join(sys.prefix, 'Scripts')

    # buildout uses 'bin' on Windows too?

    if not os.path.exists(bin_py):

        bin_py = os.path.join(sys.prefix, 'bin')

    config_dir = os.environ.get('APPDATA', user_dir) # Use %APPDATA% for roaming

    default_config_file = os.path.join(config_dir, 'pip', 'pip.ini')

else:

    bin_py = os.path.join(sys.prefix, 'bin')

    default_config_file = os.path.join(user_dir, '.pip', 'pip.conf')

    # Forcing to use /usr/local/bin for standard Mac OS X framework installs

    if sys.platform[:6] == 'darwin' and sys.prefix[:16] == '/System/Library/':

        bin_py = '/usr/local/bin'

class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):

    """Custom help formatter for use in ConfigOptionParser that updates

    the defaults before expanding them, allowing them to show up correctly

    in the help listing"""

    def expand_default(self, option):

        if self.parser is not None:

            self.parser.update_defaults(self.parser.defaults)

        return optparse.IndentedHelpFormatter.expand_default(self, option)

class ConfigOptionParser(optparse.OptionParser):

    """Custom option parser which updates its defaults by by checking the

    configuration files and environmental variables"""

    def __init__(self, *args, **kwargs):

        self.config = ConfigParser.RawConfigParser()

        self.name = kwargs.pop('name')

        self.files = self.get_config_files()

        self.config.read(self.files)

        assert self.name

        optparse.OptionParser.__init__(self, *args, **kwargs)

    def get_config_files(self):

        config_file = os.environ.get('PIP_CONFIG_FILE', False)

        if config_file and os.path.exists(config_file):

            return [config_file]

        return [default_config_file]

    def update_defaults(self, defaults):

        """Updates the given defaults with values from the config files and

        the environ. Does a little special handling for certain types of

        options (lists)."""

        # Then go and look for the other sources of configuration:

        config = {}

        # 1. config files

        for section in ('global', self.name):

            config.update(dict(self.get_config_section(section)))

        # 2. environmental variables

        config.update(dict(self.get_environ_vars()))

        # Then set the options with those values

        for key, val in config.iteritems():

            key = key.replace('_', '-')

            if not key.startswith('--'):

                key = '--%s' % key # only prefer long opts

            option = self.get_option(key)

            if option is not None:

                # ignore empty values

                if not val:

                    continue

                # handle multiline configs

                if option.action == 'append':

                    val = val.split()

                else:

                    option.nargs = 1

                if option.action in ('store_true', 'store_false', 'count'):

                    val = strtobool(val)

                try:

                    val = option.convert_value(key, val)

                except optparse.OptionValueError, e:

                    print ("An error occured during configuration: %s" % e)

                    sys.exit(3)

                defaults[option.dest] = val

        return defaults

    def get_config_section(self, name):

        """Get a section of a configuration"""

        if self.config.has_section(name):

            return self.config.items(name)

        return []

    def get_environ_vars(self, prefix='PIP_'):

        """Returns a generator with all environmental vars with prefix PIP_"""

        for key, val in os.environ.iteritems():

            if key.startswith(prefix):

                yield (key.replace(prefix, '').lower(), val)

    def get_default_values(self):

        """Overridding to make updating the defaults after instantiation of

        the option parser possible, update_defaults() does the dirty work."""

        if not self.process_default_values:

            # Old, pre-Optik 1.5 behaviour.

            return optparse.Values(self.defaults)

        defaults = self.update_defaults(self.defaults.copy()) # ours

        for option in self._get_all_options():

            default = defaults.get(option.dest)

            if isinstance(default, basestring):

                opt_str = option.get_opt_string()

                defaults[option.dest] = option.check_value(opt_str, default)

        return optparse.Values(defaults)

try:

    pip_dist = pkg_resources.get_distribution('pip')

    version = '%s from %s (python %s)' % (

        pip_dist, pip_dist.location, sys.version[:3])

except pkg_resources.DistributionNotFound:

    # when running pip.py without installing

    version=None

def rmtree_errorhandler(func, path, exc_info):

    """On Windows, the files in .svn are read-only, so when rmtree() tries to

    remove them, an exception is thrown.  We catch that here, remove the

    read-only attribute, and hopefully continue without problems."""

    exctype, value = exc_info[:2]

    # lookin for a windows error

    if exctype is not WindowsError or 'Access is denied' not in str(value):

        raise

    # file type should currently be read only

    if ((os.stat(path).st_mode & stat.S_IREAD) != stat.S_IREAD):

        raise

    # convert to read/write

    os.chmod(path, stat.S_IWRITE)

    # use the original function to repeat the operation

    func(path)

class VcsSupport(object):

    _registry = {}

    schemes = ['ssh', 'git', 'hg', 'bzr', 'sftp']

    def __init__(self):

        # Register more schemes with urlparse for various version control systems

        urlparse.uses_netloc.extend(self.schemes)

        urlparse.uses_fragment.extend(self.schemes)

        super(VcsSupport, self).__init__()

    def __iter__(self):

        return self._registry.__iter__()

    @property

    def backends(self):

        return self._registry.values()

    @property

    def dirnames(self):

        return [backend.dirname for backend in self.backends]

    @property

    def all_schemes(self):

        schemes = []

        for backend in self.backends:

            schemes.extend(backend.schemes)

        return schemes

    def register(self, cls):

        if not hasattr(cls, 'name'):

            logger.warn('Cannot register VCS %s' % cls.__name__)

            return

        if cls.name not in self._registry:

            self._registry[cls.name] = cls

    def unregister(self, cls=None, name=None):

        if name in self._registry:

            del self._registry[name]

        elif cls in self._registry.values():

            del self._registry[cls.name]

        else:

            logger.warn('Cannot unregister because no class or name given')

    def get_backend_name(self, location):

        """

        Return the name of the version control backend if found at given

        location, e.g. vcs.get_backend_name('/path/to/vcs/checkout')

        """

        for vc_type in self._registry.values():

            path = os.path.join(location, vc_type.dirname)

            if os.path.exists(path):

                return vc_type.name

        return None

    def get_backend(self, name):

        name = name.lower()

        if name in self._registry:

            return self._registry[name]

    def get_backend_from_location(self, location):

        vc_type = self.get_backend_name(location)

        if vc_type:

            return self.get_backend(vc_type)

        return None

vcs = VcsSupport()

parser = ConfigOptionParser(

    usage='%prog COMMAND [OPTIONS]',

    version=version,

    add_help_option=False,

    formatter=UpdatingDefaultsHelpFormatter(),

    name='global')

parser.add_option(

    '-h', '--help',

    dest='help',

    action='store_true',

    help='Show help')

parser.add_option(

    '-E', '--environment',

    dest='venv',

    metavar='DIR',

    help='virtualenv environment to run pip in (either give the '

    'interpreter or the environment base directory)')

parser.add_option(

    '-s', '--enable-site-packages',

    dest='site_packages',

    action='store_true',

    help='Include site-packages in virtualenv if one is to be '

    'created. Ignored if --environment is not used or '

    'the virtualenv already exists.')

parser.add_option(

    # Defines a default root directory for virtualenvs, relative

    # virtualenvs names/paths are considered relative to it.

    '--virtualenv-base',

    dest='venv_base',

    type='str',

    default='',

    help=optparse.SUPPRESS_HELP)

parser.add_option(

    # Run only if inside a virtualenv, bail if not.

    '--require-virtualenv', '--require-venv',

    dest='require_venv',

    action='store_true',

    default=False,

    help=optparse.SUPPRESS_HELP)

parser.add_option(

    # Use automatically an activated virtualenv instead of installing

    # globally. -E will be ignored if used.

    '--respect-virtualenv', '--respect-venv',

    dest='respect_venv',

    action='store_true',

    default=False,

    help=optparse.SUPPRESS_HELP)

parser.add_option(

    '-v', '--verbose',

    dest='verbose',

    action='count',

    default=0,

    help='Give more output')

parser.add_option(

    '-q', '--quiet',

    dest='quiet',

    action='count',

    default=0,

    help='Give less output')

parser.add_option(

    '--log',

    dest='log',

    metavar='FILENAME',

    help='Log file where a complete (maximum verbosity) record will be kept')

parser.add_option(

    # Writes the log levels explicitely to the log'

    '--log-explicit-levels',

    dest='log_explicit_levels',

    action='store_true',

    default=False,

    help=optparse.SUPPRESS_HELP)

parser.add_option(

    # The default log file

    '--local-log', '--log-file',

    dest='log_file',

    metavar='FILENAME',

    default='./pip-log.txt',

    help=optparse.SUPPRESS_HELP)

parser.add_option(

    '--proxy',

    dest='proxy',

    type='str',

    default='',

    help="Specify a proxy in the form user:passwd@proxy.server:port. "

    "Note that the user:password@ is optional and required only if you "

    "are behind an authenticated proxy.  If you provide "

    "user@proxy.server:port then you will be prompted for a password.")

parser.add_option(

    '--timeout', '--default-timeout',

    metavar='SECONDS',

    dest='timeout',

    type='float',

    default=15,

    help='Set the socket timeout (default %default seconds)')

parser.add_option(

    # The default version control system for editables, e.g. 'svn'

    '--default-vcs',

    dest='default_vcs',

    type='str',

    default='',

    help=optparse.SUPPRESS_HELP)

parser.add_option(

    # A regex to be used to skip requirements

    '--skip-requirements-regex',

    dest='skip_requirements_regex',

    type='str',

    default='',

    help=optparse.SUPPRESS_HELP)

parser.disable_interspersed_args()

_commands = {}

class Command(object):

    name = None

    usage = None

    hidden = False

    def __init__(self):

        assert self.name

        self.parser = ConfigOptionParser(

            usage=self.usage,

            prog='%s %s' % (sys.argv[0], self.name),

            version=parser.version,

            formatter=UpdatingDefaultsHelpFormatter(),

            name=self.name)

        for option in parser.option_list:

            if not option.dest or option.dest == 'help':

                # -h, --version, etc

                continue

            self.parser.add_option(option)

        _commands[self.name] = self

    def merge_options(self, initial_options, options):

        # Make sure we have all global options carried over

        for attr in ['log', 'venv', 'proxy', 'venv_base', 'require_venv',

                     'respect_venv', 'log_explicit_levels', 'log_file',

                     'timeout', 'default_vcs', 'skip_requirements_regex']:

            setattr(options, attr, getattr(initial_options, attr) or getattr(options, attr))

        options.quiet += initial_options.quiet

        options.verbose += initial_options.verbose

    def main(self, complete_args, args, initial_options):

        global logger

        options, args = self.parser.parse_args(args)

        self.merge_options(initial_options, options)

        if options.require_venv and not options.venv:

            # If a venv is required check if it can really be found

            if not os.environ.get('VIRTUAL_ENV'):

                print 'Could not find an activated virtualenv (required).'

                sys.exit(3)

            # Automatically install in currently activated venv if required

            options.respect_venv = True

        if args and args[-1] == '___VENV_RESTART___':

            ## FIXME: We don't do anything this this value yet:

            venv_location = args[-2]

            args = args[:-2]

            options.venv = None

        else:

            # If given the option to respect the activated environment

            # check if no venv is given as a command line parameter

            if options.respect_venv and os.environ.get('VIRTUAL_ENV'):

                if options.venv and os.path.exists(options.venv):

                    # Make sure command line venv and environmental are the same

                    if (os.path.realpath(os.path.expanduser(options.venv)) !=

                            os.path.realpath(os.environ.get('VIRTUAL_ENV'))):

                        print ("Given virtualenv (%s) doesn't match "

                               "currently activated virtualenv (%s)."

                               % (options.venv, os.environ.get('VIRTUAL_ENV')))

                        sys.exit(3)

                else:

                    options.venv = os.environ.get('VIRTUAL_ENV')

                    print 'Using already activated environment %s' % options.venv

        level = 1 # Notify

        level += options.verbose

        level -= options.quiet

        level = Logger.level_for_integer(4-level)

        complete_log = []

        logger = Logger([(level, sys.stdout),

                         (Logger.DEBUG, complete_log.append)])

        if options.log_explicit_levels:

            logger.explicit_levels = True

        if options.venv:

            if options.verbose > 0:

                # The logger isn't setup yet

                print 'Running in environment %s' % options.venv

            site_packages=False

            if options.site_packages:

                site_packages=True

            restart_in_venv(options.venv, options.venv_base, site_packages,

                            complete_args)

            # restart_in_venv should actually never return, but for clarity...

            return

        ## FIXME: not sure if this sure come before or after venv restart

        if options.log:

            log_fp = open_logfile_append(options.log)

            logger.consumers.append((logger.DEBUG, log_fp))

        else:

            log_fp = None

        socket.setdefaulttimeout(options.timeout or None)

        setup_proxy_handler(options.proxy)

        exit = 0

        try:

            self.run(options, args)

        except (InstallationError, UninstallationError), e:

            logger.fatal(str(e))

            logger.info('Exception information:\n%s' % format_exc())

            exit = 1

        except:

            logger.fatal('Exception:\n%s' % format_exc())

            exit = 2

        if log_fp is not None:

            log_fp.close()

        if exit:

            log_fn = options.log_file

            text = '\n'.join(complete_log)

            logger.fatal('Storing complete log in %s' % log_fn)

            log_fp = open_logfile_append(log_fn)

            log_fp.write(text)

            log_fp.close()

        return exit

class HelpCommand(Command):

    name = 'help'

    usage = '%prog'

    summary = 'Show available commands'

    def run(self, options, args):

        if args:

            ## FIXME: handle errors better here

            command = args[0]

            if command not in _commands:

                raise InstallationError('No command with the name: %s' % command)

            command = _commands[command]

            command.parser.print_help()

            return

        parser.print_help()

        print

        print 'Commands available:'

        commands = list(set(_commands.values()))

        commands.sort(key=lambda x: x.name)

        for command in commands:

            if command.hidden:

                continue

            print '  %s: %s' % (command.name, command.summary)

HelpCommand()

class InstallCommand(Command):