/env/lib/python3.3/site-packages/pip/req.py
Python | 1734 lines | 1551 code | 88 blank | 95 comment | 278 complexity | 142db887ef55e9f4c79f605ccfe8d746 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- from email.parser import FeedParser
- import os
- import imp
- import pkg_resources
- import re
- import sys
- import shutil
- import tempfile
- import textwrap
- import zipfile
- from distutils.util import change_root
- from pip.locations import (bin_py, running_under_virtualenv,PIP_DELETE_MARKER_FILENAME,
- write_delete_marker_file)
- from pip.exceptions import (InstallationError, UninstallationError,
- BestVersionAlreadyInstalled,
- DistributionNotFound, PreviousBuildDirError)
- from pip.vcs import vcs
- from pip.log import logger
- from pip.util import (display_path, rmtree, ask, ask_path_exists, backup_dir,
- is_installable_dir, is_local, dist_is_local,
- dist_in_usersite, dist_in_site_packages, renames,
- normalize_path, egg_link_path, make_path_relative,
- call_subprocess, is_prerelease, normalize_name)
- from pip.backwardcompat import (urlparse, urllib, uses_pycache,
- ConfigParser, string_types, HTTPError,
- get_python_version, b)
- from pip.index import Link
- from pip.locations import build_prefix
- from pip.download import (get_file_content, is_url, url_to_path,
- path_to_url, is_archive_file,
- unpack_vcs_link, is_vcs_url, is_file_url,
- unpack_file_url, unpack_http_url)
- import pip.wheel
- from pip.wheel import move_wheel_files
- class InstallRequirement(object):
- def __init__(self, req, comes_from, source_dir=None, editable=False,
- url=None, as_egg=False, update=True, prereleases=None,
- from_bundle=False):
- self.extras = ()
- if isinstance(req, string_types):
- req = pkg_resources.Requirement.parse(req)
- self.extras = req.extras
- self.req = req
- self.comes_from = comes_from
- self.source_dir = source_dir
- self.editable = editable
- self.url = url
- self.as_egg = as_egg
- self._egg_info_path = None
- # This holds the pkg_resources.Distribution object if this requirement
- # is already available:
- self.satisfied_by = None
- # This hold the pkg_resources.Distribution object if this requirement
- # conflicts with another installed distribution:
- self.conflicts_with = None
- self._temp_build_dir = None
- self._is_bundle = None
- # True if the editable should be updated:
- self.update = update
- # Set to True after successful installation
- self.install_succeeded = None
- # UninstallPathSet of uninstalled distribution (for possible rollback)
- self.uninstalled = None
- self.use_user_site = False
- self.target_dir = None
- self.from_bundle = from_bundle
- # True if pre-releases are acceptable
- if prereleases:
- self.prereleases = True
- elif self.req is not None:
- self.prereleases = any([is_prerelease(x[1]) and x[0] != "!=" for x in self.req.specs])
- else:
- self.prereleases = False
- @classmethod
- def from_editable(cls, editable_req, comes_from=None, default_vcs=None):
- name, url, extras_override = parse_editable(editable_req, default_vcs)
- if url.startswith('file:'):
- source_dir = url_to_path(url)
- else:
- source_dir = None
- res = cls(name, comes_from, source_dir=source_dir, editable=True, url=url, prereleases=True)
- if extras_override is not None:
- res.extras = extras_override
- return res
- @classmethod
- def from_line(cls, name, comes_from=None, prereleases=None):
- """Creates an InstallRequirement from a name, which might be a
- requirement, directory containing 'setup.py', filename, or URL.
- """
- url = None
- name = name.strip()
- req = None
- path = os.path.normpath(os.path.abspath(name))
- link = None
- if is_url(name):
- link = Link(name)
- elif os.path.isdir(path) and (os.path.sep in name or name.startswith('.')):
- if not is_installable_dir(path):
- raise InstallationError("Directory %r is not installable. File 'setup.py' not found." % name)
- link = Link(path_to_url(name))
- elif is_archive_file(path):
- if not os.path.isfile(path):
- logger.warn('Requirement %r looks like a filename, but the file does not exist', name)
- link = Link(path_to_url(name))
- # If the line has an egg= definition, but isn't editable, pull the requirement out.
- # Otherwise, assume the name is the req for the non URL/path/archive case.
- if link and req is None:
- url = link.url_without_fragment
- req = link.egg_fragment #when fragment is None, this will become an 'unnamed' requirement
- # Handle relative file URLs
- if link.scheme == 'file' and re.search(r'\.\./', url):
- url = path_to_url(os.path.normpath(os.path.abspath(link.path)))
- else:
- req = name
- return cls(req, comes_from, url=url, prereleases=prereleases)
- def __str__(self):
- if self.req:
- s = str(self.req)
- if self.url:
- s += ' from %s' % self.url
- else:
- s = self.url
- if self.satisfied_by is not None:
- s += ' in %s' % display_path(self.satisfied_by.location)
- if self.comes_from:
- if isinstance(self.comes_from, string_types):
- comes_from = self.comes_from
- else:
- comes_from = self.comes_from.from_path()
- if comes_from:
- s += ' (from %s)' % comes_from
- return s
- def from_path(self):
- if self.req is None:
- return None
- s = str(self.req)
- if self.comes_from:
- if isinstance(self.comes_from, string_types):
- comes_from = self.comes_from
- else:
- comes_from = self.comes_from.from_path()
- if comes_from:
- s += '->' + comes_from
- return s
- def build_location(self, build_dir, unpack=True):
- if self._temp_build_dir is not None:
- return self._temp_build_dir
- if self.req is None:
- self._temp_build_dir = tempfile.mkdtemp('-build', 'pip-')
- self._ideal_build_dir = build_dir
- return self._temp_build_dir
- if self.editable:
- name = self.name.lower()
- else:
- name = self.name
- # FIXME: Is there a better place to create the build_dir? (hg and bzr need this)
- if not os.path.exists(build_dir):
- _make_build_dir(build_dir)
- return os.path.join(build_dir, name)
- def correct_build_location(self):
- """If the build location was a temporary directory, this will move it
- to a new more permanent location"""
- if self.source_dir is not None:
- return
- assert self.req is not None
- assert self._temp_build_dir
- old_location = self._temp_build_dir
- new_build_dir = self._ideal_build_dir
- del self._ideal_build_dir
- if self.editable:
- name = self.name.lower()
- else:
- name = self.name
- new_location = os.path.join(new_build_dir, name)
- if not os.path.exists(new_build_dir):
- logger.debug('Creating directory %s' % new_build_dir)
- _make_build_dir(new_build_dir)
- if os.path.exists(new_location):
- raise InstallationError(
- 'A package already exists in %s; please remove it to continue'
- % display_path(new_location))
- logger.debug('Moving package %s from %s to new location %s'
- % (self, display_path(old_location), display_path(new_location)))
- shutil.move(old_location, new_location)
- self._temp_build_dir = new_location
- self.source_dir = new_location
- self._egg_info_path = None
- @property
- def name(self):
- if self.req is None:
- return None
- return self.req.project_name
- @property
- def url_name(self):
- if self.req is None:
- return None
- return urllib.quote(self.req.unsafe_name)
- @property
- def setup_py(self):
- return os.path.join(self.source_dir, 'setup.py')
- def run_egg_info(self, force_root_egg_info=False):
- assert self.source_dir
- if self.name:
- logger.notify('Running setup.py egg_info for package %s' % self.name)
- else:
- logger.notify('Running setup.py egg_info for package from %s' % self.url)
- logger.indent += 2
- try:
- # if it's distribute>=0.7, it won't contain an importable
- # setuptools, and having an egg-info dir blocks the ability of
- # setup.py to find setuptools plugins, so delete the egg-info dir if
- # no setuptools. it will get recreated by the run of egg_info
- # NOTE: this self.name check only works when installing from a specifier
- # (not archive path/urls)
- # TODO: take this out later
- if self.name == 'distribute' and not os.path.isdir(os.path.join(self.source_dir, 'setuptools')):
- rmtree(os.path.join(self.source_dir, 'distribute.egg-info'))
- script = self._run_setup_py
- script = script.replace('__SETUP_PY__', repr(self.setup_py))
- script = script.replace('__PKG_NAME__', repr(self.name))
- egg_info_cmd = [sys.executable, '-c', script, 'egg_info']
- # We can't put the .egg-info files at the root, because then the source code will be mistaken
- # for an installed egg, causing problems
- if self.editable or force_root_egg_info:
- egg_base_option = []
- else:
- egg_info_dir = os.path.join(self.source_dir, 'pip-egg-info')
- if not os.path.exists(egg_info_dir):
- os.makedirs(egg_info_dir)
- egg_base_option = ['--egg-base', 'pip-egg-info']
- call_subprocess(
- egg_info_cmd + egg_base_option,
- cwd=self.source_dir, filter_stdout=self._filter_install, show_stdout=False,
- command_level=logger.VERBOSE_DEBUG,
- command_desc='python setup.py egg_info')
- finally:
- logger.indent -= 2
- if not self.req:
- self.req = pkg_resources.Requirement.parse(
- "%(Name)s==%(Version)s" % self.pkg_info())
- self.correct_build_location()
- ## FIXME: This is a lame hack, entirely for PasteScript which has
- ## a self-provided entry point that causes this awkwardness
- _run_setup_py = """
- __file__ = __SETUP_PY__
- from setuptools.command import egg_info
- import pkg_resources
- import os
- def replacement_run(self):
- self.mkpath(self.egg_info)
- installer = self.distribution.fetch_build_egg
- for ep in pkg_resources.iter_entry_points('egg_info.writers'):
- # require=False is the change we're making:
- writer = ep.load(require=False)
- if writer:
- writer(self, ep.name, os.path.join(self.egg_info,ep.name))
- self.find_sources()
- egg_info.egg_info.run = replacement_run
- exec(compile(open(__file__).read().replace('\\r\\n', '\\n'), __file__, 'exec'))
- """
- def egg_info_data(self, filename):
- if self.satisfied_by is not None:
- if not self.satisfied_by.has_metadata(filename):
- return None
- return self.satisfied_by.get_metadata(filename)
- assert self.source_dir
- filename = self.egg_info_path(filename)
- if not os.path.exists(filename):
- return None
- fp = open(filename, 'r')
- data = fp.read()
- fp.close()
- return data
- def egg_info_path(self, filename):
- if self._egg_info_path is None:
- if self.editable:
- base = self.source_dir
- else:
- base = os.path.join(self.source_dir, 'pip-egg-info')
- filenames = os.listdir(base)
- if self.editable:
- filenames = []
- for root, dirs, files in os.walk(base):
- for dir in vcs.dirnames:
- if dir in dirs:
- dirs.remove(dir)
- # Iterate over a copy of ``dirs``, since mutating
- # a list while iterating over it can cause trouble.
- # (See https://github.com/pypa/pip/pull/462.)
- for dir in list(dirs):
- # Don't search in anything that looks like a virtualenv environment
- if (os.path.exists(os.path.join(root, dir, 'bin', 'python'))
- or os.path.exists(os.path.join(root, dir, 'Scripts', 'Python.exe'))):
- dirs.remove(dir)
- # Also don't search through tests
- if dir == 'test' or dir == 'tests':
- dirs.remove(dir)
- filenames.extend([os.path.join(root, dir)
- for dir in dirs])
- filenames = [f for f in filenames if f.endswith('.egg-info')]
- if not filenames:
- raise InstallationError('No files/directories in %s (from %s)' % (base, filename))
- assert filenames, "No files/directories in %s (from %s)" % (base, filename)
- # if we have more than one match, we pick the toplevel one. This can
- # easily be the case if there is a dist folder which contains an
- # extracted tarball for testing purposes.
- if len(filenames) > 1:
- filenames.sort(key=lambda x: x.count(os.path.sep) +
- (os.path.altsep and
- x.count(os.path.altsep) or 0))
- self._egg_info_path = os.path.join(base, filenames[0])
- return os.path.join(self._egg_info_path, filename)
- def egg_info_lines(self, filename):
- data = self.egg_info_data(filename)
- if not data:
- return []
- result = []
- for line in data.splitlines():
- line = line.strip()
- if not line or line.startswith('#'):
- continue
- result.append(line)
- return result
- def pkg_info(self):
- p = FeedParser()
- data = self.egg_info_data('PKG-INFO')
- if not data:
- logger.warn('No PKG-INFO file found in %s' % display_path(self.egg_info_path('PKG-INFO')))
- p.feed(data or '')
- return p.close()
- @property
- def dependency_links(self):
- return self.egg_info_lines('dependency_links.txt')
- _requirements_section_re = re.compile(r'\[(.*?)\]')
- def requirements(self, extras=()):
- in_extra = None
- for line in self.egg_info_lines('requires.txt'):
- match = self._requirements_section_re.match(line.lower())
- if match:
- in_extra = match.group(1)
- continue
- if in_extra and in_extra not in extras:
- logger.debug('skipping extra %s' % in_extra)
- # Skip requirement for an extra we aren't requiring
- continue
- yield line
- @property
- def absolute_versions(self):
- for qualifier, version in self.req.specs:
- if qualifier == '==':
- yield version
- @property
- def installed_version(self):
- return self.pkg_info()['version']
- def assert_source_matches_version(self):
- assert self.source_dir
- version = self.installed_version
- if version not in self.req:
- logger.warn('Requested %s, but installing version %s' % (self, self.installed_version))
- else:
- logger.debug('Source in %s has version %s, which satisfies requirement %s'
- % (display_path(self.source_dir), version, self))
- def update_editable(self, obtain=True):
- if not self.url:
- logger.info("Cannot update repository at %s; repository location is unknown" % self.source_dir)
- return
- assert self.editable
- assert self.source_dir
- if self.url.startswith('file:'):
- # Static paths don't get updated
- return
- assert '+' in self.url, "bad url: %r" % self.url
- if not self.update:
- return
- vc_type, url = self.url.split('+', 1)
- backend = vcs.get_backend(vc_type)
- if backend:
- vcs_backend = backend(self.url)
- if obtain:
- vcs_backend.obtain(self.source_dir)
- else:
- vcs_backend.export(self.source_dir)
- else:
- assert 0, (
- 'Unexpected version control type (in %s): %s'
- % (self.url, vc_type))
- def uninstall(self, auto_confirm=False):
- """
- Uninstall the distribution currently satisfying this requirement.
- Prompts before removing or modifying files unless
- ``auto_confirm`` is True.
- Refuses to delete or modify files outside of ``sys.prefix`` -
- thus uninstallation within a virtual environment can only
- modify that virtual environment, even if the virtualenv is
- linked to global site-packages.
- """
- if not self.check_if_exists():
- raise UninstallationError("Cannot uninstall requirement %s, not installed" % (self.name,))
- dist = self.satisfied_by or self.conflicts_with
- paths_to_remove = UninstallPathSet(dist)
- pip_egg_info_path = os.path.join(dist.location,
- dist.egg_name()) + '.egg-info'
- dist_info_path = os.path.join(dist.location,
- '-'.join(dist.egg_name().split('-')[:2])
- ) + '.dist-info'
- # workaround for http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=618367
- debian_egg_info_path = pip_egg_info_path.replace(
- '-py%s' % pkg_resources.PY_MAJOR, '')
- easy_install_egg = dist.egg_name() + '.egg'
- develop_egg_link = egg_link_path(dist)
- pip_egg_info_exists = os.path.exists(pip_egg_info_path)
- debian_egg_info_exists = os.path.exists(debian_egg_info_path)
- dist_info_exists = os.path.exists(dist_info_path)
- if pip_egg_info_exists or debian_egg_info_exists:
- # package installed by pip
- if pip_egg_info_exists:
- egg_info_path = pip_egg_info_path
- else:
- egg_info_path = debian_egg_info_path
- paths_to_remove.add(egg_info_path)
- if dist.has_metadata('installed-files.txt'):
- for installed_file in dist.get_metadata('installed-files.txt').splitlines():
- path = os.path.normpath(os.path.join(egg_info_path, installed_file))
- paths_to_remove.add(path)
- #FIXME: need a test for this elif block
- #occurs with --single-version-externally-managed/--record outside of pip
- elif dist.has_metadata('top_level.txt'):
- if dist.has_metadata('namespace_packages.txt'):
- namespaces = dist.get_metadata('namespace_packages.txt')
- else:
- namespaces = []
- for top_level_pkg in [p for p
- in dist.get_metadata('top_level.txt').splitlines()
- if p and p not in namespaces]:
- path = os.path.join(dist.location, top_level_pkg)
- paths_to_remove.add(path)
- paths_to_remove.add(path + '.py')
- paths_to_remove.add(path + '.pyc')
- elif dist.location.endswith(easy_install_egg):
- # package installed by easy_install
- paths_to_remove.add(dist.location)
- easy_install_pth = os.path.join(os.path.dirname(dist.location),
- 'easy-install.pth')
- paths_to_remove.add_pth(easy_install_pth, './' + easy_install_egg)
- elif develop_egg_link:
- # develop egg
- fh = open(develop_egg_link, 'r')
- link_pointer = os.path.normcase(fh.readline().strip())
- fh.close()
- assert (link_pointer == dist.location), 'Egg-link %s does not match installed location of %s (at %s)' % (link_pointer, self.name, dist.location)
- paths_to_remove.add(develop_egg_link)
- easy_install_pth = os.path.join(os.path.dirname(develop_egg_link),
- 'easy-install.pth')
- paths_to_remove.add_pth(easy_install_pth, dist.location)
- elif dist_info_exists:
- for path in pip.wheel.uninstallation_paths(dist):
- paths_to_remove.add(path)
- # find distutils scripts= scripts
- if dist.has_metadata('scripts') and dist.metadata_isdir('scripts'):
- for script in dist.metadata_listdir('scripts'):
- paths_to_remove.add(os.path.join(bin_py, script))
- if sys.platform == 'win32':
- paths_to_remove.add(os.path.join(bin_py, script) + '.bat')
- # find console_scripts
- if dist.has_metadata('entry_points.txt'):
- config = ConfigParser.SafeConfigParser()
- config.readfp(FakeFile(dist.get_metadata_lines('entry_points.txt')))
- if config.has_section('console_scripts'):
- for name, value in config.items('console_scripts'):
- paths_to_remove.add(os.path.join(bin_py, name))
- if sys.platform == 'win32':
- paths_to_remove.add(os.path.join(bin_py, name) + '.exe')
- paths_to_remove.add(os.path.join(bin_py, name) + '.exe.manifest')
- paths_to_remove.add(os.path.join(bin_py, name) + '-script.py')
- paths_to_remove.remove(auto_confirm)
- self.uninstalled = paths_to_remove
- def rollback_uninstall(self):
- if self.uninstalled:
- self.uninstalled.rollback()
- else:
- logger.error("Can't rollback %s, nothing uninstalled."
- % (self.project_name,))
- def commit_uninstall(self):
- if self.uninstalled:
- self.uninstalled.commit()
- else:
- logger.error("Can't commit %s, nothing uninstalled."
- % (self.project_name,))
- def archive(self, build_dir):
- assert self.source_dir
- create_archive = True
- archive_name = '%s-%s.zip' % (self.name, self.installed_version)
- archive_path = os.path.join(build_dir, archive_name)
- if os.path.exists(archive_path):
- response = ask_path_exists(
- 'The file %s exists. (i)gnore, (w)ipe, (b)ackup ' %
- display_path(archive_path), ('i', 'w', 'b'))
- if response == 'i':
- create_archive = False
- elif response == 'w':
- logger.warn('Deleting %s' % display_path(archive_path))
- os.remove(archive_path)
- elif response == 'b':
- dest_file = backup_dir(archive_path)
- logger.warn('Backing up %s to %s'
- % (display_path(archive_path), display_path(dest_file)))
- shutil.move(archive_path, dest_file)
- if create_archive:
- zip = zipfile.ZipFile(archive_path, 'w', zipfile.ZIP_DEFLATED)
- dir = os.path.normcase(os.path.abspath(self.source_dir))
- for dirpath, dirnames, filenames in os.walk(dir):
- if 'pip-egg-info' in dirnames:
- dirnames.remove('pip-egg-info')
- for dirname in dirnames:
- dirname = os.path.join(dirpath, dirname)
- name = self._clean_zip_name(dirname, dir)
- zipdir = zipfile.ZipInfo(self.name + '/' + name + '/')
- zipdir.external_attr = 0x1ED << 16 # 0o755
- zip.writestr(zipdir, '')
- for filename in filenames:
- if filename == PIP_DELETE_MARKER_FILENAME:
- continue
- filename = os.path.join(dirpath, filename)
- name = self._clean_zip_name(filename, dir)
- zip.write(filename, self.name + '/' + name)
- zip.close()
- logger.indent -= 2
- logger.notify('Saved %s' % display_path(archive_path))
- def _clean_zip_name(self, name, prefix):
- assert name.startswith(prefix+os.path.sep), (
- "name %r doesn't start with prefix %r" % (name, prefix))
- name = name[len(prefix)+1:]
- name = name.replace(os.path.sep, '/')
- return name
- def install(self, install_options, global_options=(), root=None):
- if self.editable:
- self.install_editable(install_options, global_options)
- return
- if self.is_wheel:
- self.move_wheel_files(self.source_dir)
- self.install_succeeded = True
- return
- temp_location = tempfile.mkdtemp('-record', 'pip-')
- record_filename = os.path.join(temp_location, 'install-record.txt')
- try:
- install_args = [sys.executable]
- install_args.append('-c')
- install_args.append(
- "import setuptools;__file__=%r;"\
- "exec(compile(open(__file__).read().replace('\\r\\n', '\\n'), __file__, 'exec'))" % self.setup_py)
- install_args += list(global_options) + ['install','--record', record_filename]
- if not self.as_egg:
- install_args += ['--single-version-externally-managed']
- if root is not None:
- install_args += ['--root', root]
- if running_under_virtualenv():
- ## FIXME: I'm not sure if this is a reasonable location; probably not
- ## but we can't put it in the default location, as that is a virtualenv symlink that isn't writable
- install_args += ['--install-headers',
- os.path.join(sys.prefix, 'include', 'site',
- 'python' + get_python_version())]
- logger.notify('Running setup.py install for %s' % self.name)
- logger.indent += 2
- try:
- call_subprocess(install_args + install_options,
- cwd=self.source_dir, filter_stdout=self._filter_install, show_stdout=False)
- finally:
- logger.indent -= 2
- if not os.path.exists(record_filename):
- logger.notify('Record file %s not found' % record_filename)
- return
- self.install_succeeded = True
- if self.as_egg:
- # there's no --always-unzip option we can pass to install command
- # so we unable to save the installed-files.txt
- return
- def prepend_root(path):
- if root is None or not os.path.isabs(path):
- return path
- else:
- return change_root(root, path)
- f = open(record_filename)
- for line in f:
- line = line.strip()
- if line.endswith('.egg-info'):
- egg_info_dir = prepend_root(line)
- break
- else:
- logger.warn('Could not find .egg-info directory in install record for %s' % self)
- ## FIXME: put the record somewhere
- ## FIXME: should this be an error?
- return
- f.close()
- new_lines = []
- f = open(record_filename)
- for line in f:
- filename = line.strip()
- if os.path.isdir(filename):
- filename += os.path.sep
- new_lines.append(make_path_relative(prepend_root(filename), egg_info_dir))
- f.close()
- f = open(os.path.join(egg_info_dir, 'installed-files.txt'), 'w')
- f.write('\n'.join(new_lines)+'\n')
- f.close()
- finally:
- if os.path.exists(record_filename):
- os.remove(record_filename)
- os.rmdir(temp_location)
- def remove_temporary_source(self):
- """Remove the source files from this requirement, if they are marked
- for deletion"""
- if self.is_bundle or os.path.exists(self.delete_marker_filename):
- logger.info('Removing source in %s' % self.source_dir)
- if self.source_dir:
- rmtree(self.source_dir)
- self.source_dir = None
- if self._temp_build_dir and os.path.exists(self._temp_build_dir):
- rmtree(self._temp_build_dir)
- self._temp_build_dir = None
- def install_editable(self, install_options, global_options=()):
- logger.notify('Running setup.py develop for %s' % self.name)
- logger.indent += 2
- try:
- ## FIXME: should we do --install-headers here too?
- call_subprocess(
- [sys.executable, '-c',
- "import setuptools; __file__=%r; exec(compile(open(__file__).read().replace('\\r\\n', '\\n'), __file__, 'exec'))" % self.setup_py]
- + list(global_options) + ['develop', '--no-deps'] + list(install_options),
- cwd=self.source_dir, filter_stdout=self._filter_install,
- show_stdout=False)
- finally:
- logger.indent -= 2
- self.install_succeeded = True
- def _filter_install(self, line):
- level = logger.NOTIFY
- for regex in [r'^running .*', r'^writing .*', '^creating .*', '^[Cc]opying .*',
- r'^reading .*', r"^removing .*\.egg-info' \(and everything under it\)$",
- r'^byte-compiling ',
- # Not sure what this warning is, but it seems harmless:
- r"^warning: manifest_maker: standard file '-c' not found$"]:
- if re.search(regex, line.strip()):
- level = logger.INFO
- break
- return (level, line)
- def check_if_exists(self):
- """Find an installed distribution that satisfies or conflicts
- with this requirement, and set self.satisfied_by or
- self.conflicts_with appropriately."""
- if self.req is None:
- return False
- try:
- # DISTRIBUTE TO SETUPTOOLS UPGRADE HACK (1 of 3 parts)
- # if we've already set distribute as a conflict to setuptools
- # then this check has already run before. we don't want it to
- # run again, and return False, since it would block the uninstall
- # TODO: remove this later
- if (self.req.project_name == 'setuptools'
- and self.conflicts_with
- and self.conflicts_with.project_name == 'distribute'):
- return True
- else:
- self.satisfied_by = pkg_resources.get_distribution(self.req)
- except pkg_resources.DistributionNotFound:
- return False
- except pkg_resources.VersionConflict:
- existing_dist = pkg_resources.get_distribution(self.req.project_name)
- if self.use_user_site:
- if dist_in_usersite(existing_dist):
- self.conflicts_with = existing_dist
- elif running_under_virtualenv() and dist_in_site_packages(existing_dist):
- raise InstallationError("Will not install to the user site because it will lack sys.path precedence to %s in %s"
- %(existing_dist.project_name, existing_dist.location))
- else:
- self.conflicts_with = existing_dist
- return True
- @property
- def is_wheel(self):
- return self.url and '.whl' in self.url
- @property
- def is_bundle(self):
- if self._is_bundle is not None:
- return self._is_bundle
- base = self._temp_build_dir
- if not base:
- ## FIXME: this doesn't seem right:
- return False
- self._is_bundle = (os.path.exists(os.path.join(base, 'pip-manifest.txt'))
- or os.path.exists(os.path.join(base, 'pyinstall-manifest.txt')))
- return self._is_bundle
- def bundle_requirements(self):
- for dest_dir in self._bundle_editable_dirs:
- package = os.path.basename(dest_dir)
- ## FIXME: svnism:
- for vcs_backend in vcs.backends:
- url = rev = None
- vcs_bundle_file = os.path.join(
- dest_dir, vcs_backend.bundle_file)
- if os.path.exists(vcs_bundle_file):
- vc_type = vcs_backend.name
- fp = open(vcs_bundle_file)
- content = fp.read()
- fp.close()
- url, rev = vcs_backend().parse_vcs_bundle_file(content)
- break
- if url:
- url = '%s+%s@%s' % (vc_type, url, rev)
- else:
- url = None
- yield InstallRequirement(
- package, self, editable=True, url=url,
- update=False, source_dir=dest_dir, from_bundle=True)
- for dest_dir in self._bundle_build_dirs:
- package = os.path.basename(dest_dir)
- yield InstallRequirement(package, self,source_dir=dest_dir, from_bundle=True)
- def move_bundle_files(self, dest_build_dir, dest_src_dir):
- base = self._temp_build_dir
- assert base
- src_dir = os.path.join(base, 'src')
- build_dir = os.path.join(base, 'build')
- bundle_build_dirs = []
- bundle_editable_dirs = []
- for source_dir, dest_dir, dir_collection in [
- (src_dir, dest_src_dir, bundle_editable_dirs),
- (build_dir, dest_build_dir, bundle_build_dirs)]:
- if os.path.exists(source_dir):
- for dirname in os.listdir(source_dir):
- dest = os.path.join(dest_dir, dirname)
- dir_collection.append(dest)
- if os.path.exists(dest):
- logger.warn('The directory %s (containing package %s) already exists; cannot move source from bundle %s'
- % (dest, dirname, self))
- continue
- if not os.path.exists(dest_dir):
- logger.info('Creating directory %s' % dest_dir)
- os.makedirs(dest_dir)
- shutil.move(os.path.join(source_dir, dirname), dest)
- if not os.listdir(source_dir):
- os.rmdir(source_dir)
- self._temp_build_dir = None
- self._bundle_build_dirs = bundle_build_dirs
- self._bundle_editable_dirs = bundle_editable_dirs
- def move_wheel_files(self, wheeldir):
- move_wheel_files(self.name, self.req, wheeldir, user=self.use_user_site, home=self.target_dir)
- @property
- def delete_marker_filename(self):
- assert self.source_dir
- return os.path.join(self.source_dir, PIP_DELETE_MARKER_FILENAME)
- class Requirements(object):
- def __init__(self):
- self._keys = []
- self._dict = {}
- def keys(self):
- return self._keys
- def values(self):
- return [self._dict[key] for key in self._keys]
- def __contains__(self, item):
- return item in self._keys
- def __setitem__(self, key, value):
- if key not in self._keys:
- self._keys.append(key)
- self._dict[key] = value
- def __getitem__(self, key):
- return self._dict[key]
- def __repr__(self):
- values = ['%s: %s' % (repr(k), repr(self[k])) for k in self.keys()]
- return 'Requirements({%s})' % ', '.join(values)
- class RequirementSet(object):
- def __init__(self, build_dir, src_dir, download_dir, download_cache=None,
- upgrade=False, ignore_installed=False, as_egg=False, target_dir=None,
- ignore_dependencies=False, force_reinstall=False, use_user_site=False):
- self.build_dir = build_dir
- self.src_dir = src_dir
- self.download_dir = download_dir
- self.download_cache = download_cache
- self.upgrade = upgrade
- self.ignore_installed = ignore_installed
- self.force_reinstall = force_reinstall
- self.requirements = Requirements()
- # Mapping of alias: real_name
- self.requirement_aliases = {}
- self.unnamed_requirements = []
- self.ignore_dependencies = ignore_dependencies
- self.successfully_downloaded = []
- self.successfully_installed = []
- self.reqs_to_cleanup = []
- self.as_egg = as_egg
- self.use_user_site = use_user_site
- self.target_dir = target_dir #set from --target option
- def __str__(self):
- reqs = [req for req in self.requirements.values()
- if not req.comes_from]
- reqs.sort(key=lambda req: req.name.lower())
- return ' '.join([str(req.req) for req in reqs])
- def add_requirement(self, install_req):
- name = install_req.name
- install_req.as_egg = self.as_egg
- install_req.use_user_site = self.use_user_site
- install_req.target_dir = self.target_dir
- if not name:
- #url or path requirement w/o an egg fragment
- self.unnamed_requirements.append(install_req)
- else:
- if self.has_requirement(name):
- raise InstallationError(
- 'Double requirement given: %s (already in %s, name=%r)'
- % (install_req, self.get_requirement(name), name))
- self.requirements[name] = install_req
- ## FIXME: what about other normalizations? E.g., _ vs. -?
- if name.lower() != name:
- self.requirement_aliases[name.lower()] = name
- def has_requirement(self, project_name):
- for name in project_name, project_name.lower():
- if name in self.requirements or name in self.requirement_aliases:
- return True
- return False
- @property
- def has_requirements(self):
- return list(self.requirements.values()) or self.unnamed_requirements
- @property
- def has_editables(self):
- if any(req.editable for req in self.requirements.values()):
- return True
- if any(req.editable for req in self.unnamed_requirements):
- return True
- return False
- @property
- def is_download(self):
- if self.download_dir:
- self.download_dir = os.path.expanduser(self.download_dir)
- if os.path.exists(self.download_dir):
- return True
- else:
- logger.fatal('Could not find download directory')
- raise InstallationError(
- "Could not find or access download directory '%s'"
- % display_path(self.download_dir))
- return False
- def get_requirement(self, project_name):
- for name in project_name, project_name.lower():
- if name in self.requirements:
- return self.requirements[name]
- if name in self.requirement_aliases:
- return self.requirements[self.requirement_aliases[name]]
- raise KeyError("No project with the name %r" % project_name)
- def uninstall(self, auto_confirm=False):
- for req in self.requirements.values():
- req.uninstall(auto_confirm=auto_confirm)
- req.commit_uninstall()
- def locate_files(self):
- ## FIXME: duplicates code from prepare_files; relevant code should
- ## probably be factored out into a separate method
- unnamed = list(self.unnamed_requirements)
- reqs = list(self.requirements.values())
- while reqs or unnamed:
- if unnamed:
- req_to_install = unnamed.pop(0)
- else:
- req_to_install = reqs.pop(0)
- install_needed = True
- if not self.ignore_installed and not req_to_install.editable:
- req_to_install.check_if_exists()
- if req_to_install.satisfied_by:
- if self.upgrade:
- #don't uninstall conflict if user install and and conflict is not user install
- if not (self.use_user_site and not dist_in_usersite(req_to_install.satisfied_by)):
- req_to_install.conflicts_with = req_to_install.satisfied_by
- req_to_install.satisfied_by = None
- else:
- install_needed = False
- if req_to_install.satisfied_by:
- logger.notify('Requirement already satisfied '
- '(use --upgrade to upgrade): %s'
- % req_to_install)
- if req_to_install.editable:
- if req_to_install.source_dir is None:
- req_to_install.source_dir = req_to_install.build_location(self.src_dir)
- elif install_needed:
- req_to_install.source_dir = req_to_install.build_location(self.build_dir, not self.is_download)
- if req_to_install.source_dir is not None and not os.path.isdir(req_to_install.source_dir):
- raise InstallationError('Could not install requirement %s '
- 'because source folder %s does not exist '
- '(perhaps --no-download was used without first running '
- 'an equivalent install with --no-install?)'
- % (req_to_install, req_to_install.source_dir))
- def prepare_files(self, finder, force_root_egg_info=False, bundle=False):
- """Prepare process. Create temp directories, download and/or unpack files."""
- unnamed = list(self.unnamed_requirements)
- reqs = list(self.requirements.values())
- while reqs or unnamed:
- if unnamed:
- req_to_install = unnamed.pop(0)
- else:
- req_to_install = reqs.pop(0)
- install = True
- best_installed = False
- not_found = None
- if not self.ignore_installed and not req_to_install.editable:
- req_to_install.check_if_exists()
- if req_to_install.satisfied_by:
- if self.upgrade:
- if not self.force_reinstall and not req_to_install.url:
- try:
- url = finder.find_requirement(
- req_to_install, self.upgrade)
- except BestVersionAlreadyInstalled:
- best_installed = True
- install = False
- except DistributionNotFound:
- not_found = sys.exc_info()[1]
- else:
- # Avoid the need to call find_requirement again
- req_to_install.url = url.url
- if not best_installed:
- #don't uninstall conflict if user install and conflict is not user install
- if not (self.use_user_site and not dist_in_usersite(req_to_install.satisfied_by)):
- req_to_install.conflicts_with = req_to_install.satisfied_by
- req_to_install.satisfied_by = None
- else:
- install = False
- if req_to_install.satisfied_by:
- if best_installed:
- logger.notify('Requirement already up-to-date: %s'
- % req_to_install)
- else:
- logger.notify('Requirement already satisfied '
- '(use --upgrade to upgrade): %s'
- % req_to_install)
- if req_to_install.editable:
- logger.notify('Obtaining %s' % req_to_install)
- elif install:
- if req_to_install.url and req_to_install.url.lower().startswith('file:'):
- logger.notify('Unpacking %s' % display_path(url_to_path(req_to_install.url)))
- else:
- logger.notify('Downloading/unpacking %s' % req_to_install)
- logger.indent += 2
- try:
- is_bundle = False
- is_wheel = False
- if req_to_install.editable:
- if req_to_install.source_dir is None:
- location = req_to_install.build_location(self.src_dir)
- req_to_install.source_dir = location
- else:
- location = req_to_install.source_dir
- if not os.path.exists(self.build_dir):
- _make_build_dir(self.build_dir)
- req_to_install.update_editable(not self.is_download)
- if self.is_download:
- req_to_install.run_egg_info()
- req_to_install.archive(self.download_dir)
- else:
- req_to_install.run_egg_info()
- elif install:
- ##@@ if filesystem packages are not marked
- ##editable in a req, a non deterministic error
- ##occurs when the script attempts to unpack the
- ##build directory
- # NB: This call can result in the creation of a temporary build directory
- location = req_to_install.build_location(self.build_dir, not self.is_download)
- unpack = True
- url = None
- # In the case where the req comes from a bundle, we should
- # assume a build dir exists and move on
- if req_to_install.from_bundle:
- pass
- # If a checkout exists, it's unwise to keep going. version
- # inconsistencies are logged later, but do not fail the
- # installation.
- elif os.path.exists(os.path.join(location, 'setup.py')):
- msg = textwrap.dedent("""
- pip can't proceed with requirement '%s' due to a pre-existing build directory.
- location: %s
- This is likely due to a previous installation that failed.
- pip is being responsible and not assuming it can delete this.
- Please delete it and try again.
- """ % (req_to_install, location))
- e = PreviousBuildDirError(msg)
- logger.fatal(msg)
- raise e
- else:
- ## FIXME: this won't upgrade when there's an existing package unpacked in `location`
- if req_to_install.url is None:
- if not_found:
- raise not_found
- url = finder.find_requirement(req_to_install, upgrade=self.upgrade)
- else:
- ## FIXME: should req_to_install.url already be a link?
- url = Link(req_to_install.url)
- assert url
- if url:
- try:
- self.unpack_url(url, location, self.is_download)
- except HTTPError:
- e = sys.exc_info()[1]
- logger.fatal('Could not install requirement %s because of error %s'
- % (req_to_install, e))
- raise InstallationError(
- 'Could not install requirement %s because of HTTP error %s for URL %s'
- % (req_to_install, e, url))
- else:
- unpack = False
- if unpack:
- is_bundle = req_to_install.is_bundle
- is_wheel = url and url.filename.endswith('.whl')
- if is_bundle:
- req_to_install.move_bundle_files(self.build_dir, self.src_dir)
- for subreq in req_to_install.bundle_requirements():
- reqs.append(subreq)
- self.add_requirement(subreq)
- elif self.is_download:
- req_to_install.source_dir = location
- if not is_wheel:
- # FIXME: see https://github.com/pypa/pip/issues/1112
- req_to_install.run_egg_info()
- if url and url.scheme in vcs.all_schemes:
- req_to_install.archive(self.download_dir)
- elif is_wheel:
- req_to_install.source_dir = location
- req_to_install.url = url.url
- dist = list(pkg_resources.find_distributions(location))[0]
- if not req_to_install.req:
- …
Large files files are truncated, but you can click here to view the full file