def make_requirement_preparer( temp_build_dir, # type: TempDirectory options, # type: Values req_tracker, # type: RequirementTracker session, # type: PipSession finder, # type: PackageFinder use_user_site, # type: bool download_dir=None, # type: str wheel_download_dir=None, # type: str ): # type: (...) -> RequirementPreparer """ Create a RequirementPreparer instance for the given parameters. """ downloader = Downloader(session, progress_bar=options.progress_bar) temp_build_dir_path = temp_build_dir.path assert temp_build_dir_path is not None return RequirementPreparer( build_dir=temp_build_dir_path, src_dir=options.src_dir, download_dir=download_dir, wheel_download_dir=wheel_download_dir, build_isolation=options.build_isolation, req_tracker=req_tracker, downloader=downloader, finder=finder, require_hashes=options.require_hashes, use_user_site=use_user_site, )
def make_requirement_preparer( temp_build_dir, # type: TempDirectory options, # type: Values req_tracker, # type: RequirementTracker download_dir=None, # type: str wheel_download_dir=None, # type: str ): # type: (...) -> RequirementPreparer """ Create a RequirementPreparer instance for the given parameters. """ temp_build_dir_path = temp_build_dir.path assert temp_build_dir_path is not None return RequirementPreparer( build_dir=temp_build_dir_path, src_dir=options.src_dir, download_dir=download_dir, wheel_download_dir=wheel_download_dir, progress_bar=options.progress_bar, build_isolation=options.build_isolation, req_tracker=req_tracker, )
def run(self, options, args): cmdoptions.check_install_build_global(options) upgrade_strategy = "to-satisfy-only" if options.upgrade: upgrade_strategy = options.upgrade_strategy if options.build_dir: options.build_dir = os.path.abspath(options.build_dir) cmdoptions.check_dist_restriction(options, check_target=True) if options.python_version: python_versions = [options.python_version] else: python_versions = None options.src_dir = os.path.abspath(options.src_dir) install_options = options.install_options or [] if options.use_user_site: if options.prefix_path: raise CommandError( "Can not combine '--user' and '--prefix' as they imply " "different installation locations") 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') install_options.append('--prefix=') target_temp_dir = TempDirectory(kind="target") if options.target_dir: options.ignore_installed = True 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.") # Create a target directory for using with the target option target_temp_dir.create() install_options.append('--home=' + target_temp_dir.path) global_options = options.global_options or [] 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)) wheel_cache = WheelCache(options.cache_dir, options.format_control) if options.cache_dir and not check_path_owner(options.cache_dir): logger.warning( "The directory '%s' or its parent directory is not owned " "by the current user and caching wheels has been " "disabled. check the permissions and owner of that " "directory. If executing pip with sudo, you may want " "sudo's -H flag.", options.cache_dir, ) options.cache_dir = None with RequirementTracker() as req_tracker, TempDirectory( options.build_dir, delete=build_delete, kind="install") as directory: requirement_set = RequirementSet( require_hashes=options.require_hashes, check_supported_wheels=not options.target_dir, ) try: self.populate_requirement_set(requirement_set, args, options, finder, session, self.name, wheel_cache) preparer = RequirementPreparer( build_dir=directory.path, src_dir=options.src_dir, download_dir=None, wheel_download_dir=None, progress_bar=options.progress_bar, build_isolation=options.build_isolation, req_tracker=req_tracker, ) resolver = Resolver( preparer=preparer, finder=finder, session=session, wheel_cache=wheel_cache, use_user_site=options.use_user_site, upgrade_strategy=upgrade_strategy, force_reinstall=options.force_reinstall, ignore_dependencies=options.ignore_dependencies, ignore_requires_python=options.ignore_requires_python, ignore_installed=options.ignore_installed, isolated=options.isolated_mode, use_pep517=options.use_pep517) resolver.resolve(requirement_set) protect_pip_from_modification_on_windows( modifying_pip=requirement_set.has_requirement("pip")) # Consider legacy and PEP517-using requirements separately legacy_requirements = [] pep517_requirements = [] for req in requirement_set.requirements.values(): if req.use_pep517: pep517_requirements.append(req) else: legacy_requirements.append(req) # We don't build wheels for legacy requirements if we # don't have wheel installed or we don't have a cache dir try: import wheel # noqa: F401 build_legacy = bool(options.cache_dir) except ImportError: build_legacy = False wb = WheelBuilder( finder, preparer, wheel_cache, build_options=[], global_options=[], ) # Always build PEP 517 requirements build_failures = wb.build(pep517_requirements, session=session, autobuilding=True) if build_legacy: # We don't care about failures building legacy # requirements, as we'll fall through to a direct # install for those. wb.build(legacy_requirements, session=session, autobuilding=True) # If we're using PEP 517, we cannot do a direct install # so we fail here. if build_failures: raise InstallationError( "Could not build wheels for {} which use" " PEP 517 and cannot be installed directly".format( ", ".join(r.name for r in build_failures))) to_install = resolver.get_installation_order( requirement_set) # Consistency Checking of the package set we're installing. should_warn_about_conflicts = ( not options.ignore_dependencies and options.warn_about_conflicts) if should_warn_about_conflicts: self._warn_about_conflicts(to_install) # Don't warn about script install locations if # --target has been specified warn_script_location = options.warn_script_location if options.target_dir: warn_script_location = False installed = install_given_reqs( to_install, install_options, global_options, root=options.root_path, home=target_temp_dir.path, prefix=options.prefix_path, pycompile=options.compile, warn_script_location=warn_script_location, use_user_site=options.use_user_site, ) lib_locations = get_lib_location_guesses( user=options.use_user_site, home=target_temp_dir.path, root=options.root_path, prefix=options.prefix_path, isolated=options.isolated_mode, ) working_set = pkg_resources.WorkingSet(lib_locations) reqs = sorted(installed, key=operator.attrgetter('name')) items = [] for req in reqs: item = req.name try: installed_version = get_installed_version( req.name, working_set=working_set) if installed_version: item += '-' + installed_version except Exception: pass items.append(item) installed = ' '.join(items) if installed: logger.info('Successfully installed %s', installed) except EnvironmentError as error: show_traceback = (self.verbosity >= 1) message = create_env_error_message( error, show_traceback, options.use_user_site, ) logger.error(message, exc_info=show_traceback) return ERROR except PreviousBuildDirError: options.no_clean = True raise finally: # Clean up if not options.no_clean: requirement_set.cleanup_files() wheel_cache.cleanup() if options.target_dir: self._handle_target_dir(options.target_dir, target_temp_dir, options.upgrade) return requirement_set
def resolve_reqs(self, download_dir, ireq, wheel_cache): results = None ireq.isolated = False ireq._wheel_cache = wheel_cache try: from pipenv.patched.notpip._internal.operations.prepare import RequirementPreparer except ImportError: # Pip 9 and below reqset = RequirementSet( self.build_dir, self.source_dir, download_dir=download_dir, wheel_download_dir=self._wheel_download_dir, session=self.session, ignore_installed=True, ignore_compatibility=False, wheel_cache=wheel_cache ) results = reqset._prepare_file(self.finder, ireq, ignore_requires_python=True) else: # pip >= 10 preparer_kwargs = { 'build_dir': self.build_dir, 'src_dir': self.source_dir, 'download_dir': download_dir, 'wheel_download_dir': self._wheel_download_dir, 'progress_bar': 'off', 'build_isolation': False, } resolver_kwargs = { 'finder': self.finder, 'session': self.session, 'upgrade_strategy': "to-satisfy-only", 'force_reinstall': False, 'ignore_dependencies': False, 'ignore_requires_python': True, 'ignore_installed': True, 'ignore_compatibility': False, 'isolated': False, 'wheel_cache': wheel_cache, 'use_user_site': False } resolver = None preparer = None with RequirementTracker() as req_tracker: # Pip 18 uses a requirement tracker to prevent fork bombs if req_tracker: preparer_kwargs['req_tracker'] = req_tracker preparer = RequirementPreparer(**preparer_kwargs) resolver_kwargs['preparer'] = preparer reqset = RequirementSet() ireq.is_direct = True # reqset.add_requirement(ireq) resolver = pip_shims.shims.Resolver(**resolver_kwargs) resolver.require_hashes = False results = resolver._resolve_one(reqset, ireq) cleanup_fn = getattr(reqset, "cleanup_files", None) if cleanup_fn is not None: try: cleanup_fn() except OSError: pass results = set(results) if results else set() return results, ireq
def get_legacy_dependencies(self, ireq): """ Given a pinned or an editable InstallRequirement, returns a set of dependencies (also InstallRequirements, but not necessarily pinned). They indicate the secondary dependencies for the given requirement. """ if not (ireq.editable or is_pinned_requirement(ireq)): raise TypeError( 'Expected pinned or editable InstallRequirement, got {}'. format(ireq)) if ireq not in self._dependencies_cache: if ireq.editable and (ireq.source_dir and os.path.exists(ireq.source_dir)): # No download_dir for locally available editable requirements. # If a download_dir is passed, pip will unnecessarely # archive the entire source directory download_dir = None elif ireq.link and not ireq.link.is_artifact: # No download_dir for VCS sources. This also works around pip # using git-checkout-index, which gets rid of the .git dir. download_dir = None else: download_dir = self._download_dir if not os.path.isdir(download_dir): os.makedirs(download_dir) if not os.path.isdir(self._wheel_download_dir): os.makedirs(self._wheel_download_dir) # Collect setup_requires info from local eggs. # Do this after we call the preparer on these reqs to make sure their # egg info has been created setup_requires = {} dist = None if ireq.editable: try: dist = ireq.get_dist() except InstallationError: ireq.run_egg_info() dist = ireq.get_dist() except (TypeError, ValueError, AttributeError): pass else: if dist.has_metadata('requires.txt'): setup_requires = self.finder.get_extras_links( dist.get_metadata_lines('requires.txt')) try: # Pip 9 and below reqset = RequirementSet( self.build_dir, self.source_dir, download_dir=download_dir, wheel_download_dir=self._wheel_download_dir, session=self.session, ignore_installed=True, ignore_compatibility=False, wheel_cache=self.wheel_cache, ) result = reqset._prepare_file(self.finder, ireq, ignore_requires_python=True) except TypeError: # Pip >= 10 (new resolver!) preparer = RequirementPreparer( build_dir=self.build_dir, src_dir=self.source_dir, download_dir=download_dir, wheel_download_dir=self._wheel_download_dir, progress_bar='off', build_isolation=False) reqset = RequirementSet() ireq.is_direct = True reqset.add_requirement(ireq) self.resolver = PipResolver(preparer=preparer, finder=self.finder, session=self.session, upgrade_strategy="to-satisfy-only", force_reinstall=True, ignore_dependencies=False, ignore_requires_python=True, ignore_installed=True, isolated=False, wheel_cache=self.wheel_cache, use_user_site=False, ignore_compatibility=False) self.resolver.resolve(reqset) result = set(reqset.requirements.values()) # HACK: Sometimes the InstallRequirement doesn't properly get # these values set on it during the resolution process. It's # difficult to pin down what is going wrong. This fixes things. if not getattr(ireq, 'version', None): try: dist = ireq.get_dist() if not dist else None ireq.version = ireq.get_dist().version except (ValueError, OSError, TypeError, AttributeError) as e: pass if not getattr(ireq, 'project_name', None): try: ireq.project_name = dist.project_name if dist else None except (ValueError, TypeError) as e: pass if not getattr(ireq, 'req', None): try: ireq.req = dist.as_requirement() if dist else None except (ValueError, TypeError) as e: pass # Convert setup_requires dict into a somewhat usable form. if setup_requires: for section in setup_requires: python_version = section not_python = not (section.startswith('[') and ':' in section) # This is for cleaning up :extras: formatted markers # by adding them to the results of the resolver # since any such extra would have been returned as a result anyway for value in setup_requires[section]: # This is a marker. if value.startswith('[') and ':' in value: python_version = value[1:-1] not_python = False # Strip out other extras. if value.startswith('[') and ':' not in value: not_python = True if ':' not in value: try: if not not_python: result = result + [ InstallRequirement.from_line( "{0}{1}".format( value, python_version).replace( ':', ';')) ] # Anything could go wrong here -- can't be too careful. except Exception: pass # this section properly creates 'python_version' markers for cross-python # virtualenv creation and for multi-python compatibility. requires_python = reqset.requires_python if hasattr( reqset, 'requires_python') else self.resolver.requires_python if requires_python: marker_str = '' # This corrects a logic error from the previous code which said that if # we Encountered any 'requires_python' attributes, basically only create a # single result no matter how many we resolved. This should fix # a majority of the remaining non-deterministic resolution issues. if any( requires_python.startswith(op) for op in Specifier._operators.keys()): # We are checking first if we have leading specifier operator # if not, we can assume we should be doing a == comparison specifierset = list(SpecifierSet(requires_python)) # for multiple specifiers, the correct way to represent that in # a specifierset is `Requirement('fakepkg; python_version<"3.0,>=2.6"')` marker_key = Variable('python_version') markers = [] for spec in specifierset: operator, val = spec._spec operator = Op(operator) val = Value(val) markers.append(''.join([ marker_key.serialize(), operator.serialize(), val.serialize() ])) marker_str = ' and '.join(markers) # The best way to add markers to a requirement is to make a separate requirement # with only markers on it, and then to transfer the object istelf marker_to_add = Requirement( 'fakepkg; {0}'.format(marker_str)).marker result.remove(ireq) ireq.req.marker = marker_to_add result.add(ireq) self._dependencies_cache[ireq] = result reqset.cleanup_files() return set(self._dependencies_cache[ireq])
def run(self, options, args): cmdoptions.check_install_build_global(options) index_urls = [options.index_url] + options.extra_index_urls if options.no_index: logger.debug('Ignoring indexes: %s', ','.join(index_urls)) index_urls = [] if options.build_dir: options.build_dir = os.path.abspath(options.build_dir) options.src_dir = os.path.abspath(options.src_dir) with self._build_session(options) as session: finder = self._build_package_finder(options, session) build_delete = (not (options.no_clean or options.build_dir)) wheel_cache = WheelCache(options.cache_dir, options.format_control) with TempDirectory(options.build_dir, delete=build_delete, kind="wheel") as directory: requirement_set = RequirementSet( require_hashes=options.require_hashes, ) try: self.populate_requirement_set(requirement_set, args, options, finder, session, self.name, wheel_cache) preparer = RequirementPreparer( build_dir=directory.path, src_dir=options.src_dir, download_dir=None, wheel_download_dir=options.wheel_dir, progress_bar=options.progress_bar, build_isolation=options.build_isolation, ) resolver = Resolver( preparer=preparer, finder=finder, session=session, wheel_cache=wheel_cache, use_user_site=False, upgrade_strategy="to-satisfy-only", force_reinstall=False, ignore_dependencies=options.ignore_dependencies, ignore_requires_python=options.ignore_requires_python, ignore_installed=True, isolated=options.isolated_mode, ) resolver.resolve(requirement_set) # build wheels wb = WheelBuilder( finder, preparer, wheel_cache, build_options=options.build_options or [], global_options=options.global_options or [], no_clean=options.no_clean, ) wheels_built_successfully = wb.build( requirement_set.requirements.values(), session=session, ) if not wheels_built_successfully: raise CommandError( "Failed to build one or more wheels") except PreviousBuildDirError: options.no_clean = True raise finally: if not options.no_clean: requirement_set.cleanup_files() wheel_cache.cleanup()
def run(self, options, args): options.ignore_installed = True # editable doesn't really make sense for `pip download`, but the bowels # of the RequirementSet code require that property. options.editables = [] 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(), {':all:'}) no_sdist_dependencies = (options.format_control != binary_only and not options.ignore_dependencies) if dist_restriction_set and no_sdist_dependencies: raise CommandError( "When restricting platform and interpreter constraints using " "--python-version, --platform, --abi, or --implementation, " "either --no-deps must be set, or --only-binary=:all: must be " "set and --no-binary must not be set (or must be set to " ":none:).") 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( "The directory '%s' or its parent directory is not owned " "by the current user and caching wheels has been " "disabled. check the permissions and owner of that " "directory. If executing pip with sudo, you may want " "sudo's -H flag.", options.cache_dir, ) options.cache_dir = None with TempDirectory(options.build_dir, delete=build_delete, kind="download") as directory: requirement_set = RequirementSet( require_hashes=options.require_hashes, ) self.populate_requirement_set(requirement_set, args, options, finder, session, self.name, None) preparer = RequirementPreparer( build_dir=directory.path, src_dir=options.src_dir, download_dir=options.download_dir, wheel_download_dir=None, progress_bar=options.progress_bar, build_isolation=options.build_isolation, ) resolver = Resolver( preparer=preparer, finder=finder, session=session, wheel_cache=None, use_user_site=False, upgrade_strategy="to-satisfy-only", force_reinstall=False, ignore_dependencies=options.ignore_dependencies, ignore_requires_python=False, ignore_installed=True, isolated=options.isolated_mode, ) resolver.resolve(requirement_set) 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
def resolve_reqs(self, download_dir, ireq, wheel_cache, setup_requires={}, dist=None): results = None setup_requires = {} dist = None ireq.isolated = False ireq._wheel_cache = wheel_cache try: from pipenv.patched.notpip._internal.operations.prepare import RequirementPreparer except ImportError: # Pip 9 and below reqset = RequirementSet( self.build_dir, self.source_dir, download_dir=download_dir, wheel_download_dir=self._wheel_download_dir, session=self.session, ignore_installed=True, ignore_compatibility=False, wheel_cache=wheel_cache) results = reqset._prepare_file(self.finder, ireq, ignore_requires_python=True) else: # pip >= 10 preparer_kwargs = { 'build_dir': self.build_dir, 'src_dir': self.source_dir, 'download_dir': download_dir, 'wheel_download_dir': self._wheel_download_dir, 'progress_bar': 'off', 'build_isolation': False } resolver_kwargs = { 'finder': self.finder, 'session': self.session, 'upgrade_strategy': "to-satisfy-only", 'force_reinstall': True, 'ignore_dependencies': False, 'ignore_requires_python': True, 'ignore_installed': True, 'isolated': False, 'wheel_cache': wheel_cache, 'use_user_site': False, 'ignore_compatibility': False } resolver = None preparer = None with RequirementTracker() as req_tracker: # Pip 18 uses a requirement tracker to prevent fork bombs if req_tracker: preparer_kwargs['req_tracker'] = req_tracker preparer = RequirementPreparer(**preparer_kwargs) resolver_kwargs['preparer'] = preparer reqset = RequirementSet() ireq.is_direct = True # reqset.add_requirement(ireq) resolver = PipResolver(**resolver_kwargs) resolver.require_hashes = False results = resolver._resolve_one(reqset, ireq) cleanup_fn = getattr(reqset, "cleanup_files", None) if cleanup_fn is not None: try: cleanup_fn() except OSError: pass if ireq.editable and (not ireq.source_dir or not os.path.exists(ireq.source_dir)): if ireq.editable: self._source_dir = TemporaryDirectory(fs_str("source")) ireq.ensure_has_source_dir(self.source_dir) if ireq.editable and (ireq.source_dir and os.path.exists(ireq.source_dir)): # Collect setup_requires info from local eggs. # Do this after we call the preparer on these reqs to make sure their # egg info has been created from pipenv.utils import chdir with chdir(ireq.setup_py_dir): try: from setuptools.dist import distutils dist = distutils.core.run_setup(ireq.setup_py) except InstallationError: ireq.run_egg_info() except (TypeError, ValueError, AttributeError): pass if not dist: try: dist = ireq.get_dist() except (ImportError, ValueError, TypeError, AttributeError): pass if ireq.editable and dist: setup_requires = getattr(dist, "extras_require", None) if not setup_requires: setup_requires = { "setup_requires": getattr(dist, "setup_requires", None) } if not getattr(ireq, 'req', None): try: ireq.req = dist.as_requirement() if dist else None except (ValueError, TypeError) as e: pass # Convert setup_requires dict into a somewhat usable form. if setup_requires: for section in setup_requires: python_version = section not_python = not (section.startswith('[') and ':' in section) # This is for cleaning up :extras: formatted markers # by adding them to the results of the resolver # since any such extra would have been returned as a result anyway for value in setup_requires[section]: # This is a marker. if value.startswith('[') and ':' in value: python_version = value[1:-1] not_python = False # Strip out other extras. if value.startswith('[') and ':' not in value: not_python = True if ':' not in value: try: if not not_python: results.add( InstallRequirement.from_line( "{0}{1}".format( value, python_version).replace( ':', ';'))) # Anything could go wrong here -- can't be too careful. except Exception: pass # this section properly creates 'python_version' markers for cross-python # virtualenv creation and for multi-python compatibility. requires_python = reqset.requires_python if hasattr( reqset, 'requires_python') else resolver.requires_python if requires_python: marker_str = '' # This corrects a logic error from the previous code which said that if # we Encountered any 'requires_python' attributes, basically only create a # single result no matter how many we resolved. This should fix # a majority of the remaining non-deterministic resolution issues. if any( requires_python.startswith(op) for op in Specifier._operators.keys()): # We are checking first if we have leading specifier operator # if not, we can assume we should be doing a == comparison specifierset = SpecifierSet(requires_python) # for multiple specifiers, the correct way to represent that in # a specifierset is `Requirement('fakepkg; python_version<"3.0,>=2.6"')` from passa.internals.specifiers import cleanup_pyspecs marker_str = str( Marker(" and ".join( dedup([ "python_version {0[0]} '{0[1]}'".format(spec) for spec in cleanup_pyspecs(specifierset) ])))) # The best way to add markers to a requirement is to make a separate requirement # with only markers on it, and then to transfer the object istelf marker_to_add = Requirement( 'fakepkg; {0}'.format(marker_str)).marker if ireq in results: results.remove(ireq) print(marker_to_add) ireq.req.marker = marker_to_add results = set(results) if results else set() return results, ireq
def run(self, options, args): options.ignore_installed = True # editable doesn't really make sense for `pip download`, but the bowels # of the RequirementSet code require that property. options.editables = [] if options.python_version: python_versions = [options.python_version] else: python_versions = None cmdoptions.check_dist_restriction(options) 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( "The directory '%s' or its parent directory is not owned " "by the current user and caching wheels has been " "disabled. check the permissions and owner of that " "directory. If executing pip with sudo, you may want " "sudo's -H flag.", options.cache_dir, ) options.cache_dir = None with RequirementTracker() as req_tracker, TempDirectory( options.build_dir, delete=build_delete, kind="download" ) as directory: requirement_set = RequirementSet( require_hashes=options.require_hashes, ) self.populate_requirement_set( requirement_set, args, options, finder, session, self.name, None ) preparer = RequirementPreparer( build_dir=directory.path, src_dir=options.src_dir, download_dir=options.download_dir, wheel_download_dir=None, progress_bar=options.progress_bar, build_isolation=options.build_isolation, req_tracker=req_tracker, ) resolver = Resolver( preparer=preparer, finder=finder, session=session, wheel_cache=None, use_user_site=False, upgrade_strategy="to-satisfy-only", force_reinstall=False, ignore_dependencies=options.ignore_dependencies, ignore_requires_python=False, ignore_installed=True, isolated=options.isolated_mode, ) resolver.resolve(requirement_set) 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
def get_legacy_dependencies(self, ireq): """ Given a pinned or an editable InstallRequirement, returns a set of dependencies (also InstallRequirements, but not necessarily pinned). They indicate the secondary dependencies for the given requirement. """ if not (ireq.editable or is_pinned_requirement(ireq)): raise TypeError( 'Expected pinned or editable InstallRequirement, got {}'. format(ireq)) if ireq not in self._dependencies_cache: if ireq.editable and (ireq.source_dir and os.path.exists(ireq.source_dir)): # No download_dir for locally available editable requirements. # If a download_dir is passed, pip will unnecessarely # archive the entire source directory download_dir = None elif ireq.link and not ireq.link.is_artifact: # No download_dir for VCS sources. This also works around pip # using git-checkout-index, which gets rid of the .git dir. download_dir = None else: download_dir = self._download_dir if not os.path.isdir(download_dir): os.makedirs(download_dir) if not os.path.isdir(self._wheel_download_dir): os.makedirs(self._wheel_download_dir) try: # Pip < 9 and below reqset = RequirementSet( self.build_dir, self.source_dir, download_dir=download_dir, wheel_download_dir=self._wheel_download_dir, session=self.session, ignore_installed=True, ignore_compatibility=False, wheel_cache=self.wheel_cache, ) result = reqset._prepare_file(self.finder, ireq, ignore_requires_python=True) except TypeError: # Pip >= 10 (new resolver!) preparer = RequirementPreparer( build_dir=self.build_dir, src_dir=self.source_dir, download_dir=download_dir, wheel_download_dir=self._wheel_download_dir, progress_bar='off', build_isolation=False) reqset = RequirementSet() ireq.is_direct = True reqset.add_requirement(ireq) self.resolver = PipResolver(preparer=preparer, finder=self.finder, session=self.session, upgrade_strategy="to-satisfy-only", force_reinstall=False, ignore_dependencies=False, ignore_requires_python=True, ignore_installed=True, isolated=False, wheel_cache=self.wheel_cache, use_user_site=False, ignore_compatibility=False) self.resolver.resolve(reqset) result = reqset.requirements.values() # Collect setup_requires info from local eggs. # Do this after we call the preparer on these reqs to make sure their # egg info has been created setup_requires = {} if ireq.editable: try: dist = ireq.get_dist() if dist.has_metadata('requires.txt'): setup_requires = self.finder.get_extras_links( dist.get_metadata_lines('requires.txt')) # HACK: Sometimes the InstallRequirement doesn't properly get # these values set on it during the resolution process. It's # difficult to pin down what is going wrong. This fixes things. ireq.version = dist.version ireq.project_name = dist.project_name ireq.req = dist.as_requirement() except (TypeError, ValueError): pass # Convert setup_requires dict into a somewhat usable form. if setup_requires: for section in setup_requires: python_version = section not_python = not (section.startswith('[') and ':' in section) for value in setup_requires[section]: # This is a marker. if value.startswith('[') and ':' in value: python_version = value[1:-1] not_python = False # Strip out other extras. if value.startswith('[') and ':' not in value: not_python = True if ':' not in value: try: if not not_python: result = result + [ InstallRequirement.from_line( "{0}{1}".format( value, python_version).replace( ':', ';')) ] # Anything could go wrong here — can't be too careful. except Exception: pass requires_python = reqset.requires_python if hasattr( reqset, 'requires_python') else self.resolver.requires_python if requires_python: marker = 'python_version=="{0}"'.format( requires_python.replace(' ', '')) new_req = InstallRequirement.from_line('{0}; {1}'.format( str(ireq.req), marker)) result = [new_req] self._dependencies_cache[ireq] = result reqset.cleanup_files() return set(self._dependencies_cache[ireq])
def run(self, options, args): cmdoptions.check_install_build_global(options) upgrade_strategy = "to-satisfy-only" if options.upgrade: upgrade_strategy = options.upgrade_strategy 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 options.prefix_path: raise CommandError( "Can not combine '--user' and '--prefix' as they imply " "different installation locations") 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') install_options.append('--prefix=') target_temp_dir = TempDirectory(kind="target") if options.target_dir: options.ignore_installed = True 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.") # Create a target directory for using with the target option target_temp_dir.create() install_options.append('--home=' + target_temp_dir.path) global_options = options.global_options or [] with self._build_session(options) as session: finder = self._build_package_finder(options, session) build_delete = (not (options.no_clean or options.build_dir)) wheel_cache = WheelCache(options.cache_dir, options.format_control) if options.cache_dir and not check_path_owner(options.cache_dir): logger.warning( "The directory '%s' or its parent directory is not owned " "by the current user and caching wheels has been " "disabled. check the permissions and owner of that " "directory. If executing pip with sudo, you may want " "sudo's -H flag.", options.cache_dir, ) options.cache_dir = None with TempDirectory(options.build_dir, delete=build_delete, kind="install") as directory: requirement_set = RequirementSet( require_hashes=options.require_hashes, ) try: self.populate_requirement_set(requirement_set, args, options, finder, session, self.name, wheel_cache) preparer = RequirementPreparer( build_dir=directory.path, src_dir=options.src_dir, download_dir=None, wheel_download_dir=None, progress_bar=options.progress_bar, build_isolation=options.build_isolation, ) resolver = Resolver( preparer=preparer, finder=finder, session=session, wheel_cache=wheel_cache, use_user_site=options.use_user_site, upgrade_strategy=upgrade_strategy, force_reinstall=options.force_reinstall, ignore_dependencies=options.ignore_dependencies, ignore_requires_python=options.ignore_requires_python, ignore_installed=options.ignore_installed, isolated=options.isolated_mode, ) resolver.resolve(requirement_set) # If caching is disabled or wheel is not installed don't # try to build wheels. if wheel and options.cache_dir: # build wheels before install. wb = WheelBuilder( finder, preparer, wheel_cache, build_options=[], global_options=[], ) # Ignore the result: a failed wheel will be # installed from the sdist/vcs whatever. wb.build(requirement_set.requirements.values(), session=session, autobuilding=True) to_install = resolver.get_installation_order( requirement_set) # Consistency Checking of the package set we're installing. should_warn_about_conflicts = ( not options.ignore_dependencies and options.warn_about_conflicts) if should_warn_about_conflicts: self._warn_about_conflicts(to_install) # Don't warn about script install locations if # --target has been specified warn_script_location = options.warn_script_location if options.target_dir: warn_script_location = False installed = install_given_reqs( to_install, install_options, global_options, root=options.root_path, home=target_temp_dir.path, prefix=options.prefix_path, pycompile=options.compile, warn_script_location=warn_script_location, use_user_site=options.use_user_site, ) possible_lib_locations = get_lib_location_guesses( user=options.use_user_site, home=target_temp_dir.path, root=options.root_path, prefix=options.prefix_path, isolated=options.isolated_mode, ) reqs = sorted(installed, key=operator.attrgetter('name')) items = [] for req in reqs: item = req.name try: installed_version = get_installed_version( req.name, possible_lib_locations) if installed_version: item += '-' + installed_version except Exception: pass items.append(item) installed = ' '.join(items) if installed: logger.info('Successfully installed %s', installed) except EnvironmentError as error: show_traceback = (self.verbosity >= 1) message = create_env_error_message( error, show_traceback, options.use_user_site, ) logger.error(message, exc_info=show_traceback) return ERROR except PreviousBuildDirError: options.no_clean = True raise finally: # Clean up if not options.no_clean: requirement_set.cleanup_files() wheel_cache.cleanup() if options.target_dir: self._handle_target_dir(options.target_dir, target_temp_dir, options.upgrade) return requirement_set
def make_requirement_preparer( cls, temp_build_dir: TempDirectory, options: Values, req_tracker: RequirementTracker, session: PipSession, finder: PackageFinder, use_user_site: bool, download_dir: Optional[str] = None, verbosity: int = 0, ) -> RequirementPreparer: """ Create a RequirementPreparer instance for the given parameters. """ temp_build_dir_path = temp_build_dir.path assert temp_build_dir_path is not None resolver_variant = cls.determine_resolver_variant(options) if resolver_variant == "2020-resolver": lazy_wheel = "fast-deps" in options.features_enabled if lazy_wheel: logger.warning( "pip is using lazily downloaded wheels using HTTP " "range requests to obtain dependency information. " "This experimental feature is enabled through " "--use-feature=fast-deps and it is not ready for " "production.") else: lazy_wheel = False if "fast-deps" in options.features_enabled: logger.warning( "fast-deps has no effect when used with the legacy resolver." ) in_tree_build = "out-of-tree-build" not in options.deprecated_features_enabled if "in-tree-build" in options.features_enabled: deprecated( reason="In-tree builds are now the default.", replacement="to remove the --use-feature=in-tree-build flag", gone_in="22.1", ) if "out-of-tree-build" in options.deprecated_features_enabled: deprecated( reason="Out-of-tree builds are deprecated.", replacement=None, gone_in="22.1", ) if options.progress_bar not in {"on", "off"}: deprecated( reason="Custom progress bar styles are deprecated", replacement="to use the default progress bar style.", gone_in="22.1", ) return RequirementPreparer( build_dir=temp_build_dir_path, src_dir=options.src_dir, download_dir=download_dir, build_isolation=options.build_isolation, req_tracker=req_tracker, session=session, progress_bar=options.progress_bar, finder=finder, require_hashes=options.require_hashes, use_user_site=use_user_site, lazy_wheel=lazy_wheel, verbosity=verbosity, in_tree_build=in_tree_build, )