<h2>Editing File: /usr/lib/python2.7/site-packages/pip/commands/download.py</h2><form method='post'><textarea name='content' class='file-edit'>from __future__ import absolute_import

import logging
import os

from pip.exceptions import CommandError
from pip.index import FormatControl
from pip.req import RequirementSet
from pip.basecommand import RequirementCommand
from pip import cmdoptions
from pip.utils import ensure_dir, normalize_path
from pip.utils.build import BuildDirectory
from pip.utils.filesystem import check_path_owner


logger = logging.getLogger(__name__)


class DownloadCommand(RequirementCommand):
    &quot;&quot;&quot;
    Download packages from:

    - PyPI (and other indexes) using requirement specifiers.
    - VCS project urls.
    - Local project directories.
    - Local or remote source archives.

    pip also supports downloading from &quot;requirements files&quot;, which provide
    an easy way to specify a whole environment to be downloaded.
    &quot;&quot;&quot;
    name = 'download'

    usage = &quot;&quot;&quot;
      %prog [options] &lt;requirement specifier&gt; [package-index-options] ...
      %prog [options] -r &lt;requirements file&gt; [package-index-options] ...
      %prog [options] [-e] &lt;vcs project url&gt; ...
      %prog [options] [-e] &lt;local project path&gt; ...
      %prog [options] &lt;archive url/path&gt; ...&quot;&quot;&quot;

    summary = 'Download packages.'

    def __init__(self, *args, **kw):
        super(DownloadCommand, self).__init__(*args, **kw)

        cmd_opts = self.cmd_opts

        cmd_opts.add_option(cmdoptions.constraints())
        cmd_opts.add_option(cmdoptions.editable())
        cmd_opts.add_option(cmdoptions.requirements())
        cmd_opts.add_option(cmdoptions.build_dir())
        cmd_opts.add_option(cmdoptions.no_deps())
        cmd_opts.add_option(cmdoptions.global_options())
        cmd_opts.add_option(cmdoptions.no_binary())
        cmd_opts.add_option(cmdoptions.only_binary())
        cmd_opts.add_option(cmdoptions.src())
        cmd_opts.add_option(cmdoptions.pre())
        cmd_opts.add_option(cmdoptions.no_clean())
        cmd_opts.add_option(cmdoptions.require_hashes())

        cmd_opts.add_option(
            '-d', '--dest', '--destination-dir', '--destination-directory',
            dest='download_dir',
            metavar='dir',
            default=os.curdir,
            help=(&quot;Download packages into &lt;dir&gt;.&quot;),
        )

        cmd_opts.add_option(
            '--platform',
            dest='platform',
            metavar='platform',
            default=None,
            help=(&quot;Only download wheels compatible with &lt;platform&gt;. &quot;
                  &quot;Defaults to the platform of the running system.&quot;),
        )

        cmd_opts.add_option(
            '--python-version',
            dest='python_version',
            metavar='python_version',
            default=None,
            help=(&quot;Only download wheels compatible with Python &quot;
                  &quot;interpreter version &lt;version&gt;. If not specified, then the &quot;
                  &quot;current system interpreter minor version is used. A major &quot;
                  &quot;version (e.g. '2') can be specified to match all &quot;
                  &quot;minor revs of that major version.  A minor version &quot;
                  &quot;(e.g. '34') can also be specified.&quot;),
        )

        cmd_opts.add_option(
            '--implementation',
            dest='implementation',
            metavar='implementation',
            default=None,
            help=(&quot;Only download wheels compatible with Python &quot;
                  &quot;implementation &lt;implementation&gt;, e.g. 'pp', 'jy', 'cp', &quot;
                  &quot; or 'ip'. If not specified, then the current &quot;
                  &quot;interpreter implementation is used.  Use 'py' to force &quot;
                  &quot;implementation-agnostic wheels.&quot;),
        )

        cmd_opts.add_option(
            '--abi',
            dest='abi',
            metavar='abi',
            default=None,
            help=(&quot;Only download wheels compatible with Python &quot;
                  &quot;abi &lt;abi&gt;, e.g. 'pypy_41'.  If not specified, then the &quot;
                  &quot;current interpreter abi tag is used.  Generally &quot;
                  &quot;you will need to specify --implementation, &quot;
                  &quot;--platform, and --python-version when using &quot;
                  &quot;this option.&quot;),
        )

        index_opts = cmdoptions.make_option_group(
            cmdoptions.non_deprecated_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):
        options.ignore_installed = True

        if options.python_version:
            python_versions = [options.python_version]
        else:
            python_versions = None

        dist_restriction_set = any([
            options.python_version,
            options.platform,
            options.abi,
            options.implementation,
        ])
        binary_only = FormatControl(set(), set([':all:']))
        if dist_restriction_set and options.format_control != binary_only:
            raise CommandError(
                &quot;--only-binary=:all: must be set and --no-binary must not &quot;
                &quot;be set (or must be set to :none:) when restricting platform &quot;
                &quot;and interpreter constraints using --python-version, &quot;
                &quot;--platform, --abi, or --implementation.&quot;
            )

        options.src_dir = os.path.abspath(options.src_dir)
        options.download_dir = normalize_path(options.download_dir)

        ensure_dir(options.download_dir)

        with self._build_session(options) as session:
            finder = self._build_package_finder(
                options=options,
                session=session,
                platform=options.platform,
                python_versions=python_versions,
                abi=options.abi,
                implementation=options.implementation,
            )
            build_delete = (not (options.no_clean or options.build_dir))
            if options.cache_dir and not check_path_owner(options.cache_dir):
                logger.warning(
                    &quot;The directory '%s' or its parent directory is not owned &quot;
                    &quot;by the current user and caching wheels has been &quot;
                    &quot;disabled. check the permissions and owner of that &quot;
                    &quot;directory. If executing pip with sudo, you may want &quot;
                    &quot;sudo's -H flag.&quot;,
                    options.cache_dir,
                )
                options.cache_dir = None

            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,
                    ignore_installed=True,
                    ignore_dependencies=options.ignore_dependencies,
                    session=session,
                    isolated=options.isolated_mode,
                    require_hashes=options.require_hashes
                )
                self.populate_requirement_set(
                    requirement_set,
                    args,
                    options,
                    finder,
                    session,
                    self.name,
                    None
                )

                if not requirement_set.has_requirements:
                    return

                requirement_set.prepare_files(finder)

                downloaded = ' '.join([
                    req.name for req in requirement_set.successfully_downloaded
                ])
                if downloaded:
                    logger.info(
                        'Successfully downloaded %s', downloaded
                    )

                # Clean up
                if not options.no_clean:
                    requirement_set.cleanup_files()

        return requirement_set
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fpython2.7%2Fsite-packages%2Fpip%2Fcommands'>Back to Directory</a>