com.googler.python 1.0.8 → 1.1.0

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

@@ -1,314 +0,0 @@
-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
-
-
-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 != build_prefix) 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
-        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)
-
-        requirement_set = RequirementSet(
-            build_dir=options.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

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

@@ -1,162 +0,0 @@
-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)

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

@@ -1,132 +0,0 @@
-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
-from pip._vendor 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)

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

@@ -1,80 +0,0 @@
-import os
-
-from pip.basecommand import Command
-from pip.log import logger
-from pip._vendor 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")