platform for raspberry pi

lib/python3.4/site-packages/pip/commands/__init__.py

@@ -0,0 +1,88 @@
+"""
+Package containing all pip commands
+"""
+
+
+from pip.commands.bundle import BundleCommand
+from pip.commands.completion import CompletionCommand
+from pip.commands.freeze import FreezeCommand
+from pip.commands.help import HelpCommand
+from pip.commands.list import ListCommand
+from pip.commands.search import SearchCommand
+from pip.commands.show import ShowCommand
+from pip.commands.install import InstallCommand
+from pip.commands.uninstall import UninstallCommand
+from pip.commands.unzip import UnzipCommand
+from pip.commands.zip import ZipCommand
+from pip.commands.wheel import WheelCommand
+
+
+commands = {
+    BundleCommand.name: BundleCommand,
+    CompletionCommand.name: CompletionCommand,
+    FreezeCommand.name: FreezeCommand,
+    HelpCommand.name: HelpCommand,
+    SearchCommand.name: SearchCommand,
+    ShowCommand.name: ShowCommand,
+    InstallCommand.name: InstallCommand,
+    UninstallCommand.name: UninstallCommand,
+    UnzipCommand.name: UnzipCommand,
+    ZipCommand.name: ZipCommand,
+    ListCommand.name: ListCommand,
+    WheelCommand.name: WheelCommand,
+}
+
+
+commands_order = [
+    InstallCommand,
+    UninstallCommand,
+    FreezeCommand,
+    ListCommand,
+    ShowCommand,
+    SearchCommand,
+    WheelCommand,
+    ZipCommand,
+    UnzipCommand,
+    BundleCommand,
+    HelpCommand,
+]
+
+
+def get_summaries(ignore_hidden=True, ordered=True):
+    """Yields sorted (command name, command summary) tuples."""
+
+    if ordered:
+        cmditems = _sort_commands(commands, commands_order)
+    else:
+        cmditems = commands.items()
+
+    for name, command_class in cmditems:
+        if ignore_hidden and command_class.hidden:
+            continue
+
+        yield (name, command_class.summary)
+
+
+def get_similar_commands(name):
+    """Command name auto-correct."""
+    from difflib import get_close_matches
+
+    close_commands = get_close_matches(name, commands.keys())
+
+    if close_commands:
+        guess = close_commands[0]
+    else:
+        guess = False
+
+    return guess
+
+
+def _sort_commands(cmddict, order):
+    def keyfn(key):
+        try:
+            return order.index(key[1])
+        except ValueError:
+            # unordered items should come last
+            return 0xff
+
+    return sorted(cmddict.items(), key=keyfn)

lib/python3.4/site-packages/pip/commands/bundle.py

@@ -0,0 +1,42 @@
+import textwrap
+from pip.locations import build_prefix, src_prefix
+from pip.util import display_path, backup_dir
+from pip.log import logger
+from pip.exceptions import InstallationError
+from pip.commands.install import InstallCommand
+
+
+class BundleCommand(InstallCommand):
+    """Create pybundles (archives containing multiple packages)."""
+    name = 'bundle'
+    usage = """
+      %prog [options] <bundle name>.pybundle <package>..."""
+    summary = 'DEPRECATED. Create pybundles.'
+    bundle = True
+
+    def __init__(self, *args, **kw):
+        super(BundleCommand, self).__init__(*args, **kw)
+        # bundle uses different default source and build dirs
+        build_opt = self.parser.get_option("--build")
+        build_opt.default = backup_dir(build_prefix, '-bundle')
+        src_opt = self.parser.get_option("--src")
+        src_opt.default = backup_dir(src_prefix, '-bundle')
+        self.parser.set_defaults(**{
+                src_opt.dest: src_opt.default,
+                build_opt.dest: build_opt.default,
+                })
+
+    def run(self, options, args):
+
+        logger.deprecated('1.6', "DEPRECATION: 'pip bundle' and support for installing from *.pybundle files is deprecated. "
+                    "See https://github.com/pypa/pip/pull/1046")
+
+        if not args:
+            raise InstallationError('You must give a bundle filename')
+        # We have to get everything when creating a bundle:
+        options.ignore_installed = True
+        logger.notify('Putting temporary build files in %s and source/develop files in %s'
+                      % (display_path(options.build_dir), display_path(options.src_dir)))
+        self.bundle_filename = args.pop(0)
+        requirement_set = super(BundleCommand, self).run(options, args)
+        return requirement_set

lib/python3.4/site-packages/pip/commands/completion.py

@@ -0,0 +1,59 @@
+import sys
+from pip.basecommand import Command
+
+BASE_COMPLETION = """
+# pip %(shell)s completion start%(script)s# pip %(shell)s completion end
+"""
+
+COMPLETION_SCRIPTS = {
+    'bash': """
+_pip_completion()
+{
+    COMPREPLY=( $( COMP_WORDS="${COMP_WORDS[*]}" \\
+                   COMP_CWORD=$COMP_CWORD \\
+                   PIP_AUTO_COMPLETE=1 $1 ) )
+}
+complete -o default -F _pip_completion pip
+""", 'zsh': """
+function _pip_completion {
+  local words cword
+  read -Ac words
+  read -cn cword
+  reply=( $( COMP_WORDS="$words[*]" \\
+             COMP_CWORD=$(( cword-1 )) \\
+             PIP_AUTO_COMPLETE=1 $words[1] ) )
+}
+compctl -K _pip_completion pip
+"""}
+
+
+class CompletionCommand(Command):
+    """A helper command to be used for command completion."""
+    name = 'completion'
+    summary = 'A helper command to be used for command completion'
+    hidden = True
+
+    def __init__(self, *args, **kw):
+        super(CompletionCommand, self).__init__(*args, **kw)
+        self.parser.add_option(
+            '--bash', '-b',
+            action='store_const',
+            const='bash',
+            dest='shell',
+            help='Emit completion code for bash')
+        self.parser.add_option(
+            '--zsh', '-z',
+            action='store_const',
+            const='zsh',
+            dest='shell',
+            help='Emit completion code for zsh')
+
+    def run(self, options, args):
+        """Prints the completion code of the given shell"""
+        shells = COMPLETION_SCRIPTS.keys()
+        shell_options = ['--' + shell for shell in sorted(shells)]
+        if options.shell in shells:
+            script = COMPLETION_SCRIPTS.get(options.shell, '')
+            print(BASE_COMPLETION % {'script': script, 'shell': options.shell})
+        else:
+            sys.stderr.write('ERROR: You must pass %s\n' % ' or '.join(shell_options))

lib/python3.4/site-packages/pip/commands/freeze.py

@@ -0,0 +1,114 @@
+import re
+import sys
+import pip
+
+from pip.req import InstallRequirement
+from pip.log import logger
+from pip.basecommand import Command
+from pip.util import get_installed_distributions
+import pkg_resources
+
+
+class FreezeCommand(Command):
+    """Output installed packages in requirements format."""
+    name = 'freeze'
+    usage = """
+      %prog [options]"""
+    summary = 'Output installed packages in requirements format.'
+
+    def __init__(self, *args, **kw):
+        super(FreezeCommand, self).__init__(*args, **kw)
+
+        self.cmd_opts.add_option(
+            '-r', '--requirement',
+            dest='requirement',
+            action='store',
+            default=None,
+            metavar='file',
+            help="Use the order in the given requirements file and it's comments when generating output.")
+        self.cmd_opts.add_option(
+            '-f', '--find-links',
+            dest='find_links',
+            action='append',
+            default=[],
+            metavar='URL',
+            help='URL for finding packages, which will be added to the output.')
+        self.cmd_opts.add_option(
+            '-l', '--local',
+            dest='local',
+            action='store_true',
+            default=False,
+            help='If in a virtualenv that has global access, do not output globally-installed packages.')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def setup_logging(self):
+        logger.move_stdout_to_stderr()
+
+    def run(self, options, args):
+        requirement = options.requirement
+        find_links = options.find_links or []
+        local_only = options.local
+        ## FIXME: Obviously this should be settable:
+        find_tags = False
+        skip_match = None
+
+        skip_regex = options.skip_requirements_regex
+        if skip_regex:
+            skip_match = re.compile(skip_regex)
+
+        dependency_links = []
+
+        f = sys.stdout
+
+        for dist in pkg_resources.working_set:
+            if dist.has_metadata('dependency_links.txt'):
+                dependency_links.extend(dist.get_metadata_lines('dependency_links.txt'))
+        for link in find_links:
+            if '#egg=' in link:
+                dependency_links.append(link)
+        for link in find_links:
+            f.write('-f %s\n' % link)
+        installations = {}
+        for dist in get_installed_distributions(local_only=local_only):
+            req = pip.FrozenRequirement.from_dist(dist, dependency_links, find_tags=find_tags)
+            installations[req.name] = req
+        if requirement:
+            req_f = open(requirement)
+            for line in req_f:
+                if not line.strip() or line.strip().startswith('#'):
+                    f.write(line)
+                    continue
+                if skip_match and skip_match.search(line):
+                    f.write(line)
+                    continue
+                elif line.startswith('-e') or line.startswith('--editable'):
+                    if line.startswith('-e'):
+                        line = line[2:].strip()
+                    else:
+                        line = line[len('--editable'):].strip().lstrip('=')
+                    line_req = InstallRequirement.from_editable(line, default_vcs=options.default_vcs)
+                elif (line.startswith('-r') or line.startswith('--requirement')
+                      or line.startswith('-Z') or line.startswith('--always-unzip')
+                      or line.startswith('-f') or line.startswith('-i')
+                      or line.startswith('--extra-index-url')
+                      or line.startswith('--find-links')
+                      or line.startswith('--index-url')):
+                    f.write(line)
+                    continue
+                else:
+                    line_req = InstallRequirement.from_line(line)
+                if not line_req.name:
+                    logger.notify("Skipping line because it's not clear what it would install: %s"
+                                  % line.strip())
+                    logger.notify("  (add #egg=PackageName to the URL to avoid this warning)")
+                    continue
+                if line_req.name not in installations:
+                    logger.warn("Requirement file contains %s, but that package is not installed"
+                                % line.strip())
+                    continue
+                f.write(str(installations[line_req.name]))
+                del installations[line_req.name]
+            f.write('## The following requirements were added by pip --freeze:\n')
+        for installation in sorted(installations.values(), key=lambda x: x.name):
+            f.write(str(installation))

lib/python3.4/site-packages/pip/commands/help.py

@@ -0,0 +1,33 @@
+from pip.basecommand import Command, SUCCESS
+from pip.exceptions import CommandError
+
+
+class HelpCommand(Command):
+    """Show help for commands"""
+    name = 'help'
+    usage = """
+      %prog <command>"""
+    summary = 'Show help for commands.'
+
+    def run(self, options, args):
+        from pip.commands import commands, get_similar_commands
+
+        try:
+            # 'pip help' with no args is handled by pip.__init__.parseopt()
+            cmd_name = args[0]  # the command we need help for
+        except IndexError:
+            return SUCCESS
+
+        if cmd_name not in commands:
+            guess = get_similar_commands(cmd_name)
+
+            msg = ['unknown command "%s"' % cmd_name]
+            if guess:
+                msg.append('maybe you meant "%s"' % guess)
+
+            raise CommandError(' - '.join(msg))
+
+        command = commands[cmd_name]()
+        command.parser.print_help()
+
+        return SUCCESS

lib/python3.4/site-packages/pip/commands/install.py

@@ -0,0 +1,326 @@
+import os
+import sys
+import tempfile
+import shutil
+from pip.req import InstallRequirement, RequirementSet, parse_requirements
+from pip.log import logger
+from pip.locations import (src_prefix, virtualenv_no_global, distutils_scheme,
+                           build_prefix)
+from pip.basecommand import Command
+from pip.index import PackageFinder
+from pip.exceptions import InstallationError, CommandError, PreviousBuildDirError
+from pip import cmdoptions
+from pip.util import BuildDirectory
+
+
+class InstallCommand(Command):
+    """
+    Install packages from:
+
+    - PyPI (and other indexes) using requirement specifiers.
+    - VCS project urls.
+    - Local project directories.
+    - Local or remote source archives.
+
+    pip also supports installing from "requirements files", which provide
+    an easy way to specify a whole environment to be installed.
+    """
+    name = 'install'
+
+    usage = """
+      %prog [options] <requirement specifier> ...
+      %prog [options] -r <requirements file> ...
+      %prog [options] [-e] <vcs project url> ...
+      %prog [options] [-e] <local project path> ...
+      %prog [options] <archive url/path> ..."""
+
+    summary = 'Install packages.'
+    bundle = False
+
+    def __init__(self, *args, **kw):
+        super(InstallCommand, self).__init__(*args, **kw)
+
+        cmd_opts = self.cmd_opts
+
+        cmd_opts.add_option(
+            '-e', '--editable',
+            dest='editables',
+            action='append',
+            default=[],
+            metavar='path/url',
+            help='Install a project in editable mode (i.e. setuptools "develop mode") from a local project path or a VCS url.')
+
+        cmd_opts.add_option(cmdoptions.requirements.make())
+        cmd_opts.add_option(cmdoptions.build_dir.make())
+
+        cmd_opts.add_option(
+            '-t', '--target',
+            dest='target_dir',
+            metavar='dir',
+            default=None,
+            help='Install packages into <dir>.')
+
+        cmd_opts.add_option(
+            '-d', '--download', '--download-dir', '--download-directory',
+            dest='download_dir',
+            metavar='dir',
+            default=None,
+            help="Download packages into <dir> instead of installing them, regardless of what's already installed.")
+
+        cmd_opts.add_option(cmdoptions.download_cache.make())
+
+        cmd_opts.add_option(
+            '--src', '--source', '--source-dir', '--source-directory',
+            dest='src_dir',
+            metavar='dir',
+            default=src_prefix,
+            help='Directory to check out editable projects into. '
+            'The default in a virtualenv is "<venv path>/src". '
+            'The default for global installs is "<current dir>/src".')
+
+        cmd_opts.add_option(
+            '-U', '--upgrade',
+            dest='upgrade',
+            action='store_true',
+            help='Upgrade all packages to the newest available version. '
+            'This process is recursive regardless of whether a dependency is already satisfied.')
+
+        cmd_opts.add_option(
+            '--force-reinstall',
+            dest='force_reinstall',
+            action='store_true',
+            help='When upgrading, reinstall all packages even if they are '
+                 'already up-to-date.')
+
+        cmd_opts.add_option(
+            '-I', '--ignore-installed',
+            dest='ignore_installed',
+            action='store_true',
+            help='Ignore the installed packages (reinstalling instead).')
+
+        cmd_opts.add_option(cmdoptions.no_deps.make())
+
+        cmd_opts.add_option(
+            '--no-install',
+            dest='no_install',
+            action='store_true',
+            help="DEPRECATED. Download and unpack all packages, but don't actually install them.")
+
+        cmd_opts.add_option(
+            '--no-download',
+            dest='no_download',
+            action="store_true",
+            help="DEPRECATED. Don't download any packages, just install the ones already downloaded "
+            "(completes an install run with --no-install).")
+
+        cmd_opts.add_option(cmdoptions.install_options.make())
+        cmd_opts.add_option(cmdoptions.global_options.make())
+
+        cmd_opts.add_option(
+            '--user',
+            dest='use_user_site',
+            action='store_true',
+            help='Install using the user scheme.')
+
+        cmd_opts.add_option(
+            '--egg',
+            dest='as_egg',
+            action='store_true',
+            help="Install packages as eggs, not 'flat', like pip normally does. This option is not about installing *from* eggs. (WARNING: Because this option overrides pip's normal install logic, requirements files may not behave as expected.)")
+
+        cmd_opts.add_option(
+            '--root',
+            dest='root_path',
+            metavar='dir',
+            default=None,
+            help="Install everything relative to this alternate root directory.")
+
+        cmd_opts.add_option(
+            "--compile",
+            action="store_true",
+            dest="compile",
+            default=True,
+            help="Compile py files to pyc",
+        )
+
+        cmd_opts.add_option(
+            "--no-compile",
+            action="store_false",
+            dest="compile",
+            help="Do not compile py files to pyc",
+        )
+
+        cmd_opts.add_option(cmdoptions.use_wheel.make())
+        cmd_opts.add_option(cmdoptions.no_use_wheel.make())
+
+        cmd_opts.add_option(
+            '--pre',
+            action='store_true',
+            default=False,
+            help="Include pre-release and development versions. By default, pip only finds stable versions.")
+
+        cmd_opts.add_option(cmdoptions.no_clean.make())
+
+        index_opts = cmdoptions.make_option_group(cmdoptions.index_group, self.parser)
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, cmd_opts)
+
+    def _build_package_finder(self, options, index_urls, session):
+        """
+        Create a package finder appropriate to this install command.
+        This method is meant to be overridden by subclasses, not
+        called directly.
+        """
+        return PackageFinder(find_links=options.find_links,
+                             index_urls=index_urls,
+                             use_wheel=options.use_wheel,
+                             allow_external=options.allow_external,
+                             allow_unverified=options.allow_unverified,
+                             allow_all_external=options.allow_all_external,
+                             allow_all_prereleases=options.pre,
+                             process_dependency_links=
+                                options.process_dependency_links,
+                             session=session,
+                            )
+
+    def run(self, options, args):
+
+        if (
+            options.no_install or
+            options.no_download or
+            options.build_dir or
+            options.no_clean
+        ):
+            logger.deprecated('1.7', 'DEPRECATION: --no-install, --no-download, --build, '
+                              'and --no-clean are deprecated.  See https://github.com/pypa/pip/issues/906.')
+
+        if options.download_dir:
+            options.no_install = True
+            options.ignore_installed = True
+
+        # If we have --no-install or --no-download and no --build we use the
+        # legacy static build dir
+        if (options.build_dir is None
+                and (options.no_install or options.no_download)):
+            options.build_dir = build_prefix
+
+        if options.build_dir:
+            options.build_dir = os.path.abspath(options.build_dir)
+
+        options.src_dir = os.path.abspath(options.src_dir)
+        install_options = options.install_options or []
+        if options.use_user_site:
+            if virtualenv_no_global():
+                raise InstallationError("Can not perform a '--user' install. User site-packages are not visible in this virtualenv.")
+            install_options.append('--user')
+
+        temp_target_dir = None
+        if options.target_dir:
+            options.ignore_installed = True
+            temp_target_dir = tempfile.mkdtemp()
+            options.target_dir = os.path.abspath(options.target_dir)
+            if os.path.exists(options.target_dir) and not os.path.isdir(options.target_dir):
+                raise CommandError("Target path exists but is not a directory, will not continue.")
+            install_options.append('--home=' + temp_target_dir)
+
+        global_options = options.global_options or []
+        index_urls = [options.index_url] + options.extra_index_urls
+        if options.no_index:
+            logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
+            index_urls = []
+
+        if options.use_mirrors:
+            logger.deprecated("1.7",
+                        "--use-mirrors has been deprecated and will be removed"
+                        " in the future. Explicit uses of --index-url and/or "
+                        "--extra-index-url is suggested.")
+
+        if options.mirrors:
+            logger.deprecated("1.7",
+                        "--mirrors has been deprecated and will be removed in "
+                        " the future. Explicit uses of --index-url and/or "
+                        "--extra-index-url is suggested.")
+            index_urls += options.mirrors
+
+        session = self._build_session(options)
+
+        finder = self._build_package_finder(options, index_urls, session)
+
+        build_delete = (not (options.no_clean or options.build_dir))
+        with BuildDirectory(options.build_dir, delete=build_delete) as build_dir:
+            requirement_set = RequirementSet(
+                build_dir=build_dir,
+                src_dir=options.src_dir,
+                download_dir=options.download_dir,
+                download_cache=options.download_cache,
+                upgrade=options.upgrade,
+                as_egg=options.as_egg,
+                ignore_installed=options.ignore_installed,
+                ignore_dependencies=options.ignore_dependencies,
+                force_reinstall=options.force_reinstall,
+                use_user_site=options.use_user_site,
+                target_dir=temp_target_dir,
+                session=session,
+                pycompile=options.compile,
+            )
+            for name in args:
+                requirement_set.add_requirement(
+                    InstallRequirement.from_line(name, None))
+            for name in options.editables:
+                requirement_set.add_requirement(
+                    InstallRequirement.from_editable(name, default_vcs=options.default_vcs))
+            for filename in options.requirements:
+                for req in parse_requirements(filename, finder=finder, options=options, session=session):
+                    requirement_set.add_requirement(req)
+            if not requirement_set.has_requirements:
+                opts = {'name': self.name}
+                if options.find_links:
+                    msg = ('You must give at least one requirement to %(name)s '
+                           '(maybe you meant "pip %(name)s %(links)s"?)' %
+                           dict(opts, links=' '.join(options.find_links)))
+                else:
+                    msg = ('You must give at least one requirement '
+                           'to %(name)s (see "pip help %(name)s")' % opts)
+                logger.warn(msg)
+                return
+
+            try:
+                if not options.no_download:
+                    requirement_set.prepare_files(finder, force_root_egg_info=self.bundle, bundle=self.bundle)
+                else:
+                    requirement_set.locate_files()
+
+                if not options.no_install and not self.bundle:
+                    requirement_set.install(install_options, global_options, root=options.root_path)
+                    installed = ' '.join([req.name for req in
+                                          requirement_set.successfully_installed])
+                    if installed:
+                        logger.notify('Successfully installed %s' % installed)
+                elif not self.bundle:
+                    downloaded = ' '.join([req.name for req in
+                                           requirement_set.successfully_downloaded])
+                    if downloaded:
+                        logger.notify('Successfully downloaded %s' % downloaded)
+                elif self.bundle:
+                    requirement_set.create_bundle(self.bundle_filename)
+                    logger.notify('Created bundle in %s' % self.bundle_filename)
+            except PreviousBuildDirError:
+                options.no_clean = True
+                raise
+            finally:
+                # Clean up
+                if (not options.no_clean) and ((not options.no_install) or options.download_dir):
+                    requirement_set.cleanup_files(bundle=self.bundle)
+
+        if options.target_dir:
+            if not os.path.exists(options.target_dir):
+                os.makedirs(options.target_dir)
+            lib_dir = distutils_scheme('', home=temp_target_dir)['purelib']
+            for item in os.listdir(lib_dir):
+                shutil.move(
+                    os.path.join(lib_dir, item),
+                    os.path.join(options.target_dir, item)
+                    )
+            shutil.rmtree(temp_target_dir)
+        return requirement_set

lib/python3.4/site-packages/pip/commands/list.py

@@ -0,0 +1,162 @@
+from pip.basecommand import Command
+from pip.exceptions import DistributionNotFound, BestVersionAlreadyInstalled
+from pip.index import PackageFinder
+from pip.log import logger
+from pip.req import InstallRequirement
+from pip.util import get_installed_distributions, dist_is_editable
+from pip.cmdoptions import make_option_group, index_group
+
+
+class ListCommand(Command):
+    """List installed packages, including editables."""
+    name = 'list'
+    usage = """
+      %prog [options]"""
+    summary = 'List installed packages.'
+
+    # distributions to skip (python itself is reported by pkg_resources.working_set)
+    skip = ['python']
+
+    def __init__(self, *args, **kw):
+        super(ListCommand, self).__init__(*args, **kw)
+
+        cmd_opts = self.cmd_opts
+
+        cmd_opts.add_option(
+            '-o', '--outdated',
+            action='store_true',
+            default=False,
+            help='List outdated packages (excluding editables)')
+        cmd_opts.add_option(
+            '-u', '--uptodate',
+            action='store_true',
+            default=False,
+            help='List uptodate packages (excluding editables)')
+        cmd_opts.add_option(
+            '-e', '--editable',
+            action='store_true',
+            default=False,
+            help='List editable projects.')
+        cmd_opts.add_option(
+            '-l', '--local',
+            action='store_true',
+            default=False,
+            help='If in a virtualenv that has global access, do not list globally-installed packages.')
+
+        cmd_opts.add_option(
+            '--pre',
+            action='store_true',
+            default=False,
+            help="Include pre-release and development versions. By default, pip only finds stable versions.")
+
+        index_opts = make_option_group(index_group, self.parser)
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, cmd_opts)
+
+    def _build_package_finder(self, options, index_urls, session):
+        """
+        Create a package finder appropriate to this list command.
+        """
+        return PackageFinder(find_links=options.find_links,
+                             index_urls=index_urls,
+                             allow_external=options.allow_external,
+                             allow_unverified=options.allow_unverified,
+                             allow_all_external=options.allow_all_external,
+                             allow_all_prereleases=options.pre,
+                             process_dependency_links=
+                                options.process_dependency_links,
+                             session=session,
+                        )
+
+    def run(self, options, args):
+        if options.outdated:
+            self.run_outdated(options)
+        elif options.uptodate:
+            self.run_uptodate(options)
+        elif options.editable:
+            self.run_editables(options)
+        else:
+            self.run_listing(options)
+
+    def run_outdated(self, options):
+        for dist, remote_version_raw, remote_version_parsed in self.find_packages_latests_versions(options):
+            if remote_version_parsed > dist.parsed_version:
+                logger.notify('%s (Current: %s Latest: %s)' % (dist.project_name,
+                    dist.version, remote_version_raw))
+
+    def find_packages_latests_versions(self, options):
+        index_urls = [options.index_url] + options.extra_index_urls
+        if options.no_index:
+            logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
+            index_urls = []
+
+        if options.use_mirrors:
+            logger.deprecated("1.7",
+                        "--use-mirrors has been deprecated and will be removed"
+                        " in the future. Explicit uses of --index-url and/or "
+                        "--extra-index-url is suggested.")
+
+        if options.mirrors:
+            logger.deprecated("1.7",
+                        "--mirrors has been deprecated and will be removed in "
+                        " the future. Explicit uses of --index-url and/or "
+                        "--extra-index-url is suggested.")
+            index_urls += options.mirrors
+
+        dependency_links = []
+        for dist in get_installed_distributions(local_only=options.local, skip=self.skip):
+            if dist.has_metadata('dependency_links.txt'):
+                dependency_links.extend(
+                    dist.get_metadata_lines('dependency_links.txt'),
+                )
+
+        session = self._build_session(options)
+
+        finder = self._build_package_finder(options, index_urls, session)
+        finder.add_dependency_links(dependency_links)
+
+        installed_packages = get_installed_distributions(local_only=options.local, include_editables=False, skip=self.skip)
+        for dist in installed_packages:
+            req = InstallRequirement.from_line(dist.key, None)
+            try:
+                link = finder.find_requirement(req, True)
+
+                # If link is None, means installed version is most up-to-date
+                if link is None:
+                    continue
+            except DistributionNotFound:
+                continue
+            except BestVersionAlreadyInstalled:
+                remote_version = req.installed_version
+            else:
+                # It might be a good idea that link or finder had a public method
+                # that returned version
+                remote_version = finder._link_package_versions(link, req.name)[0]
+                remote_version_raw = remote_version[2]
+                remote_version_parsed = remote_version[0]
+            yield dist, remote_version_raw, remote_version_parsed
+
+    def run_listing(self, options):
+        installed_packages = get_installed_distributions(local_only=options.local, skip=self.skip)
+        self.output_package_listing(installed_packages)
+
+    def run_editables(self, options):
+        installed_packages = get_installed_distributions(local_only=options.local, editables_only=True)
+        self.output_package_listing(installed_packages)
+
+    def output_package_listing(self, installed_packages):
+        installed_packages = sorted(installed_packages, key=lambda dist: dist.project_name.lower())
+        for dist in installed_packages:
+            if dist_is_editable(dist):
+                line = '%s (%s, %s)' % (dist.project_name, dist.version, dist.location)
+            else:
+                line = '%s (%s)' % (dist.project_name, dist.version)
+            logger.notify(line)
+
+    def run_uptodate(self, options):
+        uptodate = []
+        for dist, remote_version_raw, remote_version_parsed in self.find_packages_latests_versions(options):
+            if dist.parsed_version == remote_version_parsed:
+                uptodate.append(dist)
+        self.output_package_listing(uptodate)

lib/python3.4/site-packages/pip/commands/search.py

@@ -0,0 +1,132 @@
+import sys
+import textwrap
+
+import pip.download
+
+from pip.basecommand import Command, SUCCESS
+from pip.util import get_terminal_size
+from pip.log import logger
+from pip.backwardcompat import xmlrpclib, reduce, cmp
+from pip.exceptions import CommandError
+from pip.status_codes import NO_MATCHES_FOUND
+import pkg_resources
+from distutils.version import StrictVersion, LooseVersion
+
+
+class SearchCommand(Command):
+    """Search for PyPI packages whose name or summary contains <query>."""
+    name = 'search'
+    usage = """
+      %prog [options] <query>"""
+    summary = 'Search PyPI for packages.'
+
+    def __init__(self, *args, **kw):
+        super(SearchCommand, self).__init__(*args, **kw)
+        self.cmd_opts.add_option(
+            '--index',
+            dest='index',
+            metavar='URL',
+            default='https://pypi.python.org/pypi',
+            help='Base URL of Python Package Index (default %default)')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        if not args:
+            raise CommandError('Missing required argument (search query).')
+        query = args
+        index_url = options.index
+
+        pypi_hits = self.search(query, index_url)
+        hits = transform_hits(pypi_hits)
+
+        terminal_width = None
+        if sys.stdout.isatty():
+            terminal_width = get_terminal_size()[0]
+
+        print_results(hits, terminal_width=terminal_width)
+        if pypi_hits:
+            return SUCCESS
+        return NO_MATCHES_FOUND
+
+    def search(self, query, index_url):
+        pypi = xmlrpclib.ServerProxy(index_url)
+        hits = pypi.search({'name': query, 'summary': query}, 'or')
+        return hits
+
+
+def transform_hits(hits):
+    """
+    The list from pypi is really a list of versions. We want a list of
+    packages with the list of versions stored inline. This converts the
+    list from pypi into one we can use.
+    """
+    packages = {}
+    for hit in hits:
+        name = hit['name']
+        summary = hit['summary']
+        version = hit['version']
+        score = hit['_pypi_ordering']
+        if score is None:
+            score = 0
+
+        if name not in packages.keys():
+            packages[name] = {'name': name, 'summary': summary, 'versions': [version], 'score': score}
+        else:
+            packages[name]['versions'].append(version)
+
+            # if this is the highest version, replace summary and score
+            if version == highest_version(packages[name]['versions']):
+                packages[name]['summary'] = summary
+                packages[name]['score'] = score
+
+    # each record has a unique name now, so we will convert the dict into a list sorted by score
+    package_list = sorted(packages.values(), key=lambda x: x['score'], reverse=True)
+    return package_list
+
+
+def print_results(hits, name_column_width=25, terminal_width=None):
+    installed_packages = [p.project_name for p in pkg_resources.working_set]
+    for hit in hits:
+        name = hit['name']
+        summary = hit['summary'] or ''
+        if terminal_width is not None:
+            # wrap and indent summary to fit terminal
+            summary = textwrap.wrap(summary, terminal_width - name_column_width - 5)
+            summary = ('\n' + ' ' * (name_column_width + 3)).join(summary)
+        line = '%s - %s' % (name.ljust(name_column_width), summary)
+        try:
+            logger.notify(line)
+            if name in installed_packages:
+                dist = pkg_resources.get_distribution(name)
+                logger.indent += 2
+                try:
+                    latest = highest_version(hit['versions'])
+                    if dist.version == latest:
+                        logger.notify('INSTALLED: %s (latest)' % dist.version)
+                    else:
+                        logger.notify('INSTALLED: %s' % dist.version)
+                        logger.notify('LATEST:    %s' % latest)
+                finally:
+                    logger.indent -= 2
+        except UnicodeEncodeError:
+            pass
+
+
+def compare_versions(version1, version2):
+    try:
+        return cmp(StrictVersion(version1), StrictVersion(version2))
+    # in case of abnormal version number, fall back to LooseVersion
+    except ValueError:
+        pass
+    try:
+        return cmp(LooseVersion(version1), LooseVersion(version2))
+    except TypeError:
+    # certain LooseVersion comparions raise due to unorderable types,
+    # fallback to string comparison
+        return cmp([str(v) for v in LooseVersion(version1).version],
+                   [str(v) for v in LooseVersion(version2).version])
+
+
+def highest_version(versions):
+    return reduce((lambda v1, v2: compare_versions(v1, v2) == 1 and v1 or v2), versions)

lib/python3.4/site-packages/pip/commands/show.py

@@ -0,0 +1,80 @@
+import os
+
+from pip.basecommand import Command
+from pip.log import logger
+import pkg_resources
+
+
+class ShowCommand(Command):
+    """Show information about one or more installed packages."""
+    name = 'show'
+    usage = """
+      %prog [options] <package> ..."""
+    summary = 'Show information about installed packages.'
+
+    def __init__(self, *args, **kw):
+        super(ShowCommand, self).__init__(*args, **kw)
+        self.cmd_opts.add_option(
+            '-f', '--files',
+            dest='files',
+            action='store_true',
+            default=False,
+            help='Show the full list of installed files for each package.')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        if not args:
+            logger.warn('ERROR: Please provide a package name or names.')
+            return
+        query = args
+
+        results = search_packages_info(query)
+        print_results(results, options.files)
+
+
+def search_packages_info(query):
+    """
+    Gather details from installed distributions. Print distribution name,
+    version, location, and installed files. Installed files requires a
+    pip generated 'installed-files.txt' in the distributions '.egg-info'
+    directory.
+    """
+    installed_packages = dict(
+        [(p.project_name.lower(), p) for p in pkg_resources.working_set])
+    for name in query:
+        normalized_name = name.lower()
+        if normalized_name in installed_packages:
+            dist = installed_packages[normalized_name]
+            package = {
+                'name': dist.project_name,
+                'version': dist.version,
+                'location': dist.location,
+                'requires': [dep.project_name for dep in dist.requires()],
+            }
+            filelist = os.path.join(
+                       dist.location,
+                       dist.egg_name() + '.egg-info',
+                       'installed-files.txt')
+            if os.path.isfile(filelist):
+                package['files'] = filelist
+            yield package
+
+
+def print_results(distributions, list_all_files):
+    """
+    Print the informations from installed distributions found.
+    """
+    for dist in distributions:
+        logger.notify("---")
+        logger.notify("Name: %s" % dist['name'])
+        logger.notify("Version: %s" % dist['version'])
+        logger.notify("Location: %s" % dist['location'])
+        logger.notify("Requires: %s" % ', '.join(dist['requires']))
+        if list_all_files:
+            logger.notify("Files:")
+            if 'files' in dist:
+                for line in open(dist['files']):
+                    logger.notify("  %s" % line.strip())
+            else:
+                logger.notify("Cannot locate installed-files.txt")

lib/python3.4/site-packages/pip/commands/uninstall.py

@@ -0,0 +1,59 @@
+from pip.req import InstallRequirement, RequirementSet, parse_requirements
+from pip.basecommand import Command
+from pip.exceptions import InstallationError
+
+
+class UninstallCommand(Command):
+    """
+    Uninstall packages.
+
+    pip is able to uninstall most installed packages. Known exceptions are:
+
+    - Pure distutils packages installed with ``python setup.py install``, which
+      leave behind no metadata to determine what files were installed.
+    - Script wrappers installed by ``python setup.py develop``.
+    """
+    name = 'uninstall'
+    usage = """
+      %prog [options] <package> ...
+      %prog [options] -r <requirements file> ..."""
+    summary = 'Uninstall packages.'
+
+    def __init__(self, *args, **kw):
+        super(UninstallCommand, self).__init__(*args, **kw)
+        self.cmd_opts.add_option(
+            '-r', '--requirement',
+            dest='requirements',
+            action='append',
+            default=[],
+            metavar='file',
+            help='Uninstall all the packages listed in the given requirements file.  '
+            'This option can be used multiple times.')
+        self.cmd_opts.add_option(
+            '-y', '--yes',
+            dest='yes',
+            action='store_true',
+            help="Don't ask for confirmation of uninstall deletions.")
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options, args):
+        session = self._build_session(options)
+
+        requirement_set = RequirementSet(
+            build_dir=None,
+            src_dir=None,
+            download_dir=None,
+            session=session,
+        )
+        for name in args:
+            requirement_set.add_requirement(
+                InstallRequirement.from_line(name))
+        for filename in options.requirements:
+            for req in parse_requirements(filename,
+                    options=options, session=session):
+                requirement_set.add_requirement(req)
+        if not requirement_set.has_requirements:
+            raise InstallationError('You must give at least one requirement '
+                'to %(name)s (see "pip help %(name)s")' % dict(name=self.name))
+        requirement_set.uninstall(auto_confirm=options.yes)

lib/python3.4/site-packages/pip/commands/unzip.py

@@ -0,0 +1,7 @@
+from pip.commands.zip import ZipCommand
+
+
+class UnzipCommand(ZipCommand):
+    """Unzip individual packages."""
+    name = 'unzip'
+    summary = 'DEPRECATED. Unzip individual packages.'

lib/python3.4/site-packages/pip/commands/wheel.py

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import os
+import sys
+from pip.basecommand import Command
+from pip.index import PackageFinder
+from pip.log import logger
+from pip.exceptions import CommandError, PreviousBuildDirError
+from pip.req import InstallRequirement, RequirementSet, parse_requirements
+from pip.util import BuildDirectory, normalize_path
+from pip.wheel import WheelBuilder
+from pip import cmdoptions
+
+DEFAULT_WHEEL_DIR = os.path.join(normalize_path(os.curdir), 'wheelhouse')
+
+class WheelCommand(Command):
+    """
+    Build Wheel archives for your requirements and dependencies.
+
+    Wheel is a built-package format, and offers the advantage of not recompiling your software during every install.
+    For more details, see the wheel docs: http://wheel.readthedocs.org/en/latest.
+
+    Requirements: setuptools>=0.8, and wheel.
+
+    'pip wheel' uses the bdist_wheel setuptools extension from the wheel package to build individual wheels.
+
+    """
+
+    name = 'wheel'
+    usage = """
+      %prog [options] <requirement specifier> ...
+      %prog [options] -r <requirements file> ...
+      %prog [options] <vcs project url> ...
+      %prog [options] <local project path> ...
+      %prog [options] <archive url/path> ..."""
+
+    summary = 'Build wheels from your requirements.'
+
+    def __init__(self, *args, **kw):
+        super(WheelCommand, self).__init__(*args, **kw)
+
+        cmd_opts = self.cmd_opts
+
+        cmd_opts.add_option(
+            '-w', '--wheel-dir',
+            dest='wheel_dir',
+            metavar='dir',
+            default=DEFAULT_WHEEL_DIR,
+            help="Build wheels into <dir>, where the default is '<cwd>/wheelhouse'.")
+        cmd_opts.add_option(cmdoptions.use_wheel.make())
+        cmd_opts.add_option(cmdoptions.no_use_wheel.make())
+        cmd_opts.add_option(
+            '--build-option',
+            dest='build_options',
+            metavar='options',
+            action='append',
+            help="Extra arguments to be supplied to 'setup.py bdist_wheel'.")
+        cmd_opts.add_option(cmdoptions.requirements.make())
+        cmd_opts.add_option(cmdoptions.download_cache.make())
+        cmd_opts.add_option(cmdoptions.no_deps.make())
+        cmd_opts.add_option(cmdoptions.build_dir.make())
+
+        cmd_opts.add_option(
+            '--global-option',
+            dest='global_options',
+            action='append',
+            metavar='options',
+            help="Extra global options to be supplied to the setup.py "
+            "call before the 'bdist_wheel' command.")
+
+        cmd_opts.add_option(
+            '--pre',
+            action='store_true',
+            default=False,
+            help="Include pre-release and development versions. By default, pip only finds stable versions.")
+
+        cmd_opts.add_option(cmdoptions.no_clean.make())
+
+        index_opts = cmdoptions.make_option_group(cmdoptions.index_group, self.parser)
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, cmd_opts)
+
+    def run(self, options, args):
+
+        # confirm requirements
+        try:
+            import wheel.bdist_wheel
+        except ImportError:
+            if sys.version_info < (3,):
+                debian_package = 'python-wheel'
+            else:
+                debian_package = 'python3-wheel'
+            raise CommandError("'pip wheel' requires the 'wheel' package. To fix this, run: sudo apt-get install %s" % debian_package)
+
+        try:
+            import pkg_resources
+        except ImportError:
+            raise CommandError(
+                "'pip wheel' requires setuptools >= 0.8 for dist-info support."
+                " To fix this, run: pip install --upgrade setuptools"
+            )
+        else:
+            if not hasattr(pkg_resources, 'DistInfoDistribution'):
+                raise CommandError(
+                    "'pip wheel' requires setuptools >= 0.8 for dist-info "
+                    "support. To fix this, run: pip install --upgrade "
+                    "setuptools"
+                )
+
+        index_urls = [options.index_url] + options.extra_index_urls
+        if options.no_index:
+            logger.notify('Ignoring indexes: %s' % ','.join(index_urls))
+            index_urls = []
+
+        if options.use_mirrors:
+            logger.deprecated("1.7",
+                        "--use-mirrors has been deprecated and will be removed"
+                        " in the future. Explicit uses of --index-url and/or "
+                        "--extra-index-url is suggested.")
+
+        if options.mirrors:
+            logger.deprecated("1.7",
+                        "--mirrors has been deprecated and will be removed in "
+                        " the future. Explicit uses of --index-url and/or "
+                        "--extra-index-url is suggested.")
+            index_urls += options.mirrors
+
+        if options.build_dir:
+            options.build_dir = os.path.abspath(options.build_dir)
+
+        session = self._build_session(options)
+
+        finder = PackageFinder(find_links=options.find_links,
+                               index_urls=index_urls,
+                               use_wheel=options.use_wheel,
+                               allow_external=options.allow_external,
+                               allow_unverified=options.allow_unverified,
+                               allow_all_external=options.allow_all_external,
+                               allow_all_prereleases=options.pre,
+                               process_dependency_links=
+                                options.process_dependency_links,
+                               session=session,
+                            )
+
+        build_delete = (not (options.no_clean or options.build_dir))
+        with BuildDirectory(options.build_dir, delete=build_delete) as build_dir:
+            requirement_set = RequirementSet(
+                build_dir=build_dir,
+                src_dir=None,
+                download_dir=None,
+                download_cache=options.download_cache,
+                ignore_dependencies=options.ignore_dependencies,
+                ignore_installed=True,
+                session=session,
+                wheel_download_dir=options.wheel_dir
+            )
+
+            # make the wheelhouse
+            if not os.path.exists(options.wheel_dir):
+                os.makedirs(options.wheel_dir)
+
+            #parse args and/or requirements files
+            for name in args:
+                requirement_set.add_requirement(
+                    InstallRequirement.from_line(name, None))
+
+            for filename in options.requirements:
+                for req in parse_requirements(
+                    filename,
+                    finder=finder,
+                    options=options,
+                    session=session):
+                    if req.editable:
+                        logger.notify("ignoring %s" % req.url)
+                        continue
+                    requirement_set.add_requirement(req)
+
+            #fail if no requirements
+            if not requirement_set.has_requirements:
+                opts = {'name': self.name}
+                msg = ('You must give at least one requirement '
+                       'to %(name)s (see "pip help %(name)s")' % opts)
+                logger.error(msg)
+                return
+
+            try:
+                #build wheels
+                wb = WheelBuilder(
+                    requirement_set,
+                    finder,
+                    options.wheel_dir,
+                    build_options = options.build_options or [],
+                    global_options = options.global_options or []
+                    )
+                wb.build()
+            except PreviousBuildDirError:
+                options.no_clean = True
+                raise
+            finally:
+                if not options.no_clean:
+                    requirement_set.cleanup_files()

lib/python3.4/site-packages/pip/commands/zip.py

@@ -0,0 +1,351 @@
+import sys
+import re
+import fnmatch
+import os
+import shutil
+import zipfile
+from pip.util import display_path, backup_dir, rmtree
+from pip.log import logger
+from pip.exceptions import InstallationError
+from pip.basecommand import Command
+
+
+class ZipCommand(Command):
+    """Zip individual packages."""
+    name = 'zip'
+    usage = """
+     %prog [options] <package> ..."""
+    summary = 'DEPRECATED. Zip individual packages.'
+
+    def __init__(self, *args, **kw):
+        super(ZipCommand, self).__init__(*args, **kw)
+        if self.name == 'zip':
+            self.cmd_opts.add_option(
+                '--unzip',
+                action='store_true',
+                dest='unzip',
+                help='Unzip (rather than zip) a package.')
+        else:
+            self.cmd_opts.add_option(
+                '--zip',
+                action='store_false',
+                dest='unzip',
+                default=True,
+                help='Zip (rather than unzip) a package.')
+        self.cmd_opts.add_option(
+            '--no-pyc',
+            action='store_true',
+            dest='no_pyc',
+            help='Do not include .pyc files in zip files (useful on Google App Engine).')
+        self.cmd_opts.add_option(
+            '-l', '--list',
+            action='store_true',
+            dest='list',
+            help='List the packages available, and their zip status.')
+        self.cmd_opts.add_option(
+            '--sort-files',
+            action='store_true',
+            dest='sort_files',
+            help='With --list, sort packages according to how many files they contain.')
+        self.cmd_opts.add_option(
+            '--path',
+            action='append',
+            dest='paths',
+            help='Restrict operations to the given paths (may include wildcards).')
+        self.cmd_opts.add_option(
+            '-n', '--simulate',
+            action='store_true',
+            help='Do not actually perform the zip/unzip operation.')
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def paths(self):
+        """All the entries of sys.path, possibly restricted by --path"""
+        if not self.select_paths:
+            return sys.path
+        result = []
+        match_any = set()
+        for path in sys.path:
+            path = os.path.normcase(os.path.abspath(path))
+            for match in self.select_paths:
+                match = os.path.normcase(os.path.abspath(match))
+                if '*' in match:
+                    if re.search(fnmatch.translate(match + '*'), path):
+                        result.append(path)
+                        match_any.add(match)
+                        break
+                else:
+                    if path.startswith(match):
+                        result.append(path)
+                        match_any.add(match)
+                        break
+            else:
+                logger.debug("Skipping path %s because it doesn't match %s"
+                             % (path, ', '.join(self.select_paths)))
+        for match in self.select_paths:
+            if match not in match_any and '*' not in match:
+                result.append(match)
+                logger.debug("Adding path %s because it doesn't match "
+                             "anything already on sys.path" % match)
+        return result
+
+    def run(self, options, args):
+
+        logger.deprecated('1.7', "DEPRECATION: 'pip zip' and 'pip unzip` are deprecated, and will be removed in a future release.")
+
+        self.select_paths = options.paths
+        self.simulate = options.simulate
+        if options.list:
+            return self.list(options, args)
+        if not args:
+            raise InstallationError(
+                'You must give at least one package to zip or unzip')
+        packages = []
+        for arg in args:
+            module_name, filename = self.find_package(arg)
+            if options.unzip and os.path.isdir(filename):
+                raise InstallationError(
+                    'The module %s (in %s) is not a zip file; cannot be unzipped'
+                    % (module_name, filename))
+            elif not options.unzip and not os.path.isdir(filename):
+                raise InstallationError(
+                    'The module %s (in %s) is not a directory; cannot be zipped'
+                    % (module_name, filename))
+            packages.append((module_name, filename))
+        last_status = None
+        for module_name, filename in packages:
+            if options.unzip:
+                last_status = self.unzip_package(module_name, filename)
+            else:
+                last_status = self.zip_package(module_name, filename, options.no_pyc)
+        return last_status
+
+    def unzip_package(self, module_name, filename):
+        zip_filename = os.path.dirname(filename)
+        if not os.path.isfile(zip_filename) and zipfile.is_zipfile(zip_filename):
+            raise InstallationError(
+                'Module %s (in %s) isn\'t located in a zip file in %s'
+                % (module_name, filename, zip_filename))
+        package_path = os.path.dirname(zip_filename)
+        if not package_path in self.paths():
+            logger.warn(
+                'Unpacking %s into %s, but %s is not on sys.path'
+                % (display_path(zip_filename), display_path(package_path),
+                   display_path(package_path)))
+        logger.notify('Unzipping %s (in %s)' % (module_name, display_path(zip_filename)))
+        if self.simulate:
+            logger.notify('Skipping remaining operations because of --simulate')
+            return
+        logger.indent += 2
+        try:
+            ## FIXME: this should be undoable:
+            zip = zipfile.ZipFile(zip_filename)
+            to_save = []
+            for info in zip.infolist():
+                name = info.filename
+                if name.startswith(module_name + os.path.sep):
+                    content = zip.read(name)
+                    dest = os.path.join(package_path, name)
+                    if not os.path.exists(os.path.dirname(dest)):
+                        os.makedirs(os.path.dirname(dest))
+                    if not content and dest.endswith(os.path.sep):
+                        if not os.path.exists(dest):
+                            os.makedirs(dest)
+                    else:
+                        f = open(dest, 'wb')
+                        f.write(content)
+                        f.close()
+                else:
+                    to_save.append((name, zip.read(name)))
+            zip.close()
+            if not to_save:
+                logger.info('Removing now-empty zip file %s' % display_path(zip_filename))
+                os.unlink(zip_filename)
+                self.remove_filename_from_pth(zip_filename)
+            else:
+                logger.info('Removing entries in %s/ from zip file %s' % (module_name, display_path(zip_filename)))
+                zip = zipfile.ZipFile(zip_filename, 'w')
+                for name, content in to_save:
+                    zip.writestr(name, content)
+                zip.close()
+        finally:
+            logger.indent -= 2
+
+    def zip_package(self, module_name, filename, no_pyc):
+        orig_filename = filename
+        logger.notify('Zip %s (in %s)' % (module_name, display_path(filename)))
+        logger.indent += 2
+        if filename.endswith('.egg'):
+            dest_filename = filename
+        else:
+            dest_filename = filename + '.zip'
+        try:
+            ## FIXME: I think this needs to be undoable:
+            if filename == dest_filename:
+                filename = backup_dir(orig_filename)
+                logger.notify('Moving %s aside to %s' % (orig_filename, filename))
+                if not self.simulate:
+                    shutil.move(orig_filename, filename)
+            try:
+                logger.info('Creating zip file in %s' % display_path(dest_filename))
+                if not self.simulate:
+                    zip = zipfile.ZipFile(dest_filename, 'w')
+                    zip.writestr(module_name + '/', '')
+                    for dirpath, dirnames, filenames in os.walk(filename):
+                        if no_pyc:
+                            filenames = [f for f in filenames
+                                         if not f.lower().endswith('.pyc')]
+                        for fns, is_dir in [(dirnames, True), (filenames, False)]:
+                            for fn in fns:
+                                full = os.path.join(dirpath, fn)
+                                dest = os.path.join(module_name, dirpath[len(filename):].lstrip(os.path.sep), fn)
+                                if is_dir:
+                                    zip.writestr(dest + '/', '')
+                                else:
+                                    zip.write(full, dest)
+                    zip.close()
+                logger.info('Removing old directory %s' % display_path(filename))
+                if not self.simulate:
+                    rmtree(filename)
+            except:
+                ## FIXME: need to do an undo here
+                raise
+            ## FIXME: should also be undone:
+            self.add_filename_to_pth(dest_filename)
+        finally:
+            logger.indent -= 2
+
+    def remove_filename_from_pth(self, filename):
+        for pth in self.pth_files():
+            f = open(pth, 'r')
+            lines = f.readlines()
+            f.close()
+            new_lines = [
+                l for l in lines if l.strip() != filename]
+            if lines != new_lines:
+                logger.info('Removing reference to %s from .pth file %s'
+                            % (display_path(filename), display_path(pth)))
+                if not [line for line in new_lines if line]:
+                    logger.info('%s file would be empty: deleting' % display_path(pth))
+                    if not self.simulate:
+                        os.unlink(pth)
+                else:
+                    if not self.simulate:
+                        f = open(pth, 'wb')
+                        f.writelines(new_lines)
+                        f.close()
+                return
+        logger.warn('Cannot find a reference to %s in any .pth file' % display_path(filename))
+
+    def add_filename_to_pth(self, filename):
+        path = os.path.dirname(filename)
+        dest = filename + '.pth'
+        if path not in self.paths():
+            logger.warn('Adding .pth file %s, but it is not on sys.path' % display_path(dest))
+        if not self.simulate:
+            if os.path.exists(dest):
+                f = open(dest)
+                lines = f.readlines()
+                f.close()
+                if lines and not lines[-1].endswith('\n'):
+                    lines[-1] += '\n'
+                lines.append(filename + '\n')
+            else:
+                lines = [filename + '\n']
+            f = open(dest, 'wb')
+            f.writelines(lines)
+            f.close()
+
+    def pth_files(self):
+        for path in self.paths():
+            if not os.path.exists(path) or not os.path.isdir(path):
+                continue
+            for filename in os.listdir(path):
+                if filename.endswith('.pth'):
+                    yield os.path.join(path, filename)
+
+    def find_package(self, package):
+        for path in self.paths():
+            full = os.path.join(path, package)
+            if os.path.exists(full):
+                return package, full
+            if not os.path.isdir(path) and zipfile.is_zipfile(path):
+                zip = zipfile.ZipFile(path, 'r')
+                try:
+                    zip.read(os.path.join(package, '__init__.py'))
+                except KeyError:
+                    pass
+                else:
+                    zip.close()
+                    return package, full
+                zip.close()
+        ## FIXME: need special error for package.py case:
+        raise InstallationError(
+            'No package with the name %s found' % package)
+
+    def list(self, options, args):
+        if args:
+            raise InstallationError(
+                'You cannot give an argument with --list')
+        for path in sorted(self.paths()):
+            if not os.path.exists(path):
+                continue
+            basename = os.path.basename(path.rstrip(os.path.sep))
+            if os.path.isfile(path) and zipfile.is_zipfile(path):
+                if os.path.dirname(path) not in self.paths():
+                    logger.notify('Zipped egg: %s' % display_path(path))
+                continue
+            if (basename != 'site-packages' and basename != 'dist-packages'
+                and not path.replace('\\', '/').endswith('lib/python')):
+                continue
+            logger.notify('In %s:' % display_path(path))
+            logger.indent += 2
+            zipped = []
+            unzipped = []
+            try:
+                for filename in sorted(os.listdir(path)):
+                    ext = os.path.splitext(filename)[1].lower()
+                    if ext in ('.pth', '.egg-info', '.egg-link'):
+                        continue
+                    if ext == '.py':
+                        logger.info('Not displaying %s: not a package' % display_path(filename))
+                        continue
+                    full = os.path.join(path, filename)
+                    if os.path.isdir(full):
+                        unzipped.append((filename, self.count_package(full)))
+                    elif zipfile.is_zipfile(full):
+                        zipped.append(filename)
+                    else:
+                        logger.info('Unknown file: %s' % display_path(filename))
+                if zipped:
+                    logger.notify('Zipped packages:')
+                    logger.indent += 2
+                    try:
+                        for filename in zipped:
+                            logger.notify(filename)
+                    finally:
+                        logger.indent -= 2
+                else:
+                    logger.notify('No zipped packages.')
+                if unzipped:
+                    if options.sort_files:
+                        unzipped.sort(key=lambda x: -x[1])
+                    logger.notify('Unzipped packages:')
+                    logger.indent += 2
+                    try:
+                        for filename, count in unzipped:
+                            logger.notify('%s  (%i files)' % (filename, count))
+                    finally:
+                        logger.indent -= 2
+                else:
+                    logger.notify('No unzipped packages.')
+            finally:
+                logger.indent -= 2
+
+    def count_package(self, path):
+        total = 0
+        for dirpath, dirnames, filenames in os.walk(path):
+            filenames = [f for f in filenames
+                         if not f.lower().endswith('.pyc')]
+            total += len(filenames)
+        return total