def _build_package_finder( self, options, # type: Values session, # type: PipSession target_python=None, # type: Optional[TargetPython] ignore_requires_python=None, # type: Optional[bool] ): # type: (...) -> PackageFinder """ Create a package finder appropriate to the index command. """ link_collector = LinkCollector.create(session, options=options) # Pass allow_yanked=False to ignore yanked versions. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=options.pre, ignore_requires_python=ignore_requires_python, ) return PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, target_python=target_python, )
def _build_package_finder( self, options: Values, session: PipSession, target_python: Optional[TargetPython] = None, ignore_requires_python: Optional[bool] = None, ) -> PackageFinder: """ Create a package finder appropriate to this requirement command. :param ignore_requires_python: Whether to ignore incompatible "Requires-Python" values in links. Defaults to False. """ link_collector = LinkCollector.create(session, options=options) selection_prefs = SelectionPreferences( allow_yanked=True, format_control=options.format_control, allow_all_prereleases=options.pre, prefer_binary=options.prefer_binary, ignore_requires_python=ignore_requires_python, ) return PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, target_python=target_python, )
def _get_current_remote_pip_version(session: PipSession, options: optparse.Values) -> str: # Lets use PackageFinder to see what the latest pip version is link_collector = LinkCollector.create( session, options=options, suppress_no_index=True, ) # Pass allow_yanked=False so we don't suggest upgrading to a # yanked version. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=False, # Explicitly set to False ) finder = PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, ) best_candidate = finder.find_best_candidate("pip").best_candidate if best_candidate is None: return return str(best_candidate.version)
def test_link_collector_create_find_links_expansion(mock_expanduser: mock.Mock, tmpdir: Path) -> None: """ Test "~" expansion in --find-links paths. """ # This is a mock version of expanduser() that expands "~" to the tmpdir. def expand_path(path: str) -> str: if path.startswith("~/"): path = os.path.join(tmpdir, path[2:]) return path mock_expanduser.side_effect = expand_path session = PipSession() options = mock.Mock( find_links=["~/temp1", "~/temp2"], index_url="default_url", extra_index_urls=[], no_index=False, ) # Only create temp2 and not temp1 to test that "~" expansion only occurs # when the directory exists. temp2_dir = os.path.join(tmpdir, "temp2") os.mkdir(temp2_dir) link_collector = LinkCollector.create(session, options=options) search_scope = link_collector.search_scope # Only ~/temp2 gets expanded. Also, the path is normalized when expanded. expected_temp2_dir = os.path.normcase(temp2_dir) assert search_scope.find_links == ["~/temp1", expected_temp2_dir] assert search_scope.index_urls == ["default_url"]
def _build_package_finder( self, options: Values, session: PipSession, target_python: Optional[TargetPython] = None, ignore_requires_python: Optional[bool] = None, ) -> PackageFinder: """ Create a package finder appropriate to the index command. """ link_collector = LinkCollector.create(session, options=options) # Pass allow_yanked=False to ignore yanked versions. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=options.pre, ignore_requires_python=ignore_requires_python, ) return PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, target_python=target_python, use_deprecated_html5lib="html5lib" in options.deprecated_features_enabled, )
def test_link_collector_create_find_links_expansion( mock_expanduser, tmpdir, ): """ Test "~" expansion in --find-links paths. """ # This is a mock version of expanduser() that expands "~" to the tmpdir. def expand_path(path): if path.startswith('~/'): path = os.path.join(tmpdir, path[2:]) return path mock_expanduser.side_effect = expand_path session = PipSession() options = pretend.stub( find_links=['~/temp1', '~/temp2'], index_url='default_url', extra_index_urls=[], no_index=False, ) # Only create temp2 and not temp1 to test that "~" expansion only occurs # when the directory exists. temp2_dir = os.path.join(tmpdir, 'temp2') os.mkdir(temp2_dir) link_collector = LinkCollector.create(session, options=options) search_scope = link_collector.search_scope # Only ~/temp2 gets expanded. Also, the path is normalized when expanded. expected_temp2_dir = os.path.normcase(temp2_dir) assert search_scope.find_links == ['~/temp1', expected_temp2_dir] assert search_scope.index_urls == ['default_url']
def test_link_collector_create( find_links: List[str], no_index: bool, suppress_no_index: bool, expected: Tuple[List[str], List[str]], ) -> None: """ :param expected: the expected (find_links, index_urls) values. """ expected_find_links, expected_index_urls = expected session = PipSession() options = mock.Mock( find_links=find_links, index_url="default_url", extra_index_urls=["url1", "url2"], no_index=no_index, ) link_collector = LinkCollector.create( session, options=options, suppress_no_index=suppress_no_index, ) assert link_collector.session is session search_scope = link_collector.search_scope assert search_scope.find_links == expected_find_links assert search_scope.index_urls == expected_index_urls
def test_collect_sources__file_expand_dir(data: TestData) -> None: """ Test that a file:// dir from --find-links becomes _FlatDirectorySource """ collector = LinkCollector.create( session=mock.Mock(is_secure_origin=None), # Shouldn't be used. options=mock.Mock( index_url="ignored-by-no-index", extra_index_urls=[], no_index=True, find_links=[data.find_links], ), ) sources = collector.collect_sources( # Shouldn't be used. project_name=None, # type: ignore[arg-type] candidates_from_page=None, # type: ignore[arg-type] ) assert ( not sources.index_urls and len(sources.find_links) == 1 and isinstance(sources.find_links[0], _FlatDirectorySource) ), ( "Directory source should have been found " f"at find-links url: {data.find_links}" )
def test_link_collector_create( find_links, no_index, suppress_no_index, expected, ): """ :param expected: the expected (find_links, index_urls) values. """ expected_find_links, expected_index_urls = expected session = PipSession() options = pretend.stub( find_links=find_links, index_url='default_url', extra_index_urls=['url1', 'url2'], no_index=no_index, ) link_collector = LinkCollector.create( session, options=options, suppress_no_index=suppress_no_index, ) assert link_collector.session is session search_scope = link_collector.search_scope assert search_scope.find_links == expected_find_links assert search_scope.index_urls == expected_index_urls
def get_finder() -> PackageFinder: return PackageFinder.create( LinkCollector.create( session=PipSession(), options=Values(defaults=dict( no_index=False, index_url="https://pypi.python.org/simple", find_links=None, extra_index_urls=[""])) ), SelectionPreferences( allow_yanked=False, allow_all_prereleases=True ), use_deprecated_html5lib=False, )
def _build_package_finder(self, options, session): # type: (Values, PipSession) -> PackageFinder """ Create a package finder appropriate to this list command. """ link_collector = LinkCollector.create(session, options=options) # Pass allow_yanked=False to ignore yanked versions. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=options.pre ) return PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs )
def _build_package_finder(self, options: Values, session: PipSession) -> PackageFinder: """ Create a package finder appropriate to this list command. """ link_collector = LinkCollector.create(session, options=options) # Pass allow_yanked=False to ignore yanked versions. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=options.pre, ) return PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, use_deprecated_html5lib="html5lib" in options.deprecated_features_enabled, )
def test_collect_sources__non_existing_path(): """ Test that a non-existing path is ignored. """ collector = LinkCollector.create( session=pretend.stub(is_secure_origin=None), # Shouldn't be used. options=pretend.stub( index_url="ignored-by-no-index", extra_index_urls=[], no_index=True, find_links=[os.path.join("this", "doesnt", "exist")], ), ) sources = collector.collect_sources( project_name=None, # Shouldn't be used. candidates_from_page=None, # Shouldn't be used. ) assert (not sources.index_urls and sources.find_links == [None]), "Nothing should have been found"
def test_collect_sources__file_not_find_link(data): """ Test that a file:// dir from --index-url doesn't become _FlatDirectorySource run """ collector = LinkCollector.create( session=pretend.stub(is_secure_origin=None), # Shouldn't be used. options=pretend.stub( index_url=data.index_url("empty_with_pkg"), extra_index_urls=[], no_index=False, find_links=[], ), ) sources = collector.collect_sources( project_name="", candidates_from_page=None, # Shouldn't be used. ) assert (not sources.find_links and len(sources.index_urls) == 1 and isinstance(sources.index_urls[0], _IndexDirectorySource) ), "Directory specified as index should be treated as a page"
def pip_self_version_check(session, options): # type: (PipSession, optparse.Values) -> None """Check for an update for pip. Limit the frequency of checks to once per week. State is stored either in the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix of the pip script path. """ installed_version = get_installed_version("pip") if not installed_version: return pip_version = packaging_version.parse(installed_version) pypi_version = None try: state = SelfCheckState(cache_dir=options.cache_dir) current_time = datetime.datetime.utcnow() # Determine if we need to refresh the state if "last_check" in state.state and "pypi_version" in state.state: last_check = datetime.datetime.strptime(state.state["last_check"], SELFCHECK_DATE_FMT) if (current_time - last_check).total_seconds() < 7 * 24 * 60 * 60: pypi_version = state.state["pypi_version"] # Refresh the version if we need to or just see if we need to warn if pypi_version is None: # Lets use PackageFinder to see what the latest pip version is link_collector = LinkCollector.create( session, options=options, suppress_no_index=True, ) # Pass allow_yanked=False so we don't suggest upgrading to a # yanked version. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=False, # Explicitly set to False ) finder = PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, ) best_candidate = finder.find_best_candidate("pip").best_candidate if best_candidate is None: return pypi_version = str(best_candidate.version) # save that we've performed a check state.save(pypi_version, current_time) remote_version = packaging_version.parse(pypi_version) local_version_is_older = ( pip_version < remote_version and pip_version.base_version != remote_version.base_version and was_installed_by_pip('pip')) # Determine if our pypi_version is older if not local_version_is_older: return # We cannot tell how the current pip is available in the current # command context, so be pragmatic here and suggest the command # that's always available. This does not accommodate spaces in # `sys.executable`. pip_cmd = "{} -m pip".format(sys.executable) logger.warning( "You are using pip version %s; however, version %s is " "available.\nYou should consider upgrading via the " "'%s install --upgrade pip' command.", pip_version, pypi_version, pip_cmd) except Exception: logger.debug( "There was an error checking the latest version of pip", exc_info=True, )
def pip_self_version_check(session: PipSession, options: optparse.Values) -> None: """Check for an update for pip. Limit the frequency of checks to once per week. State is stored either in the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix of the pip script path. """ installed_dist = get_default_environment().get_distribution("pip") if not installed_dist: return pip_version = installed_dist.version pypi_version = None try: state = SelfCheckState(cache_dir=options.cache_dir) current_time = datetime.datetime.utcnow() # Determine if we need to refresh the state if "last_check" in state.state and "pypi_version" in state.state: last_check = datetime.datetime.strptime(state.state["last_check"], SELFCHECK_DATE_FMT) if (current_time - last_check).total_seconds() < 7 * 24 * 60 * 60: pypi_version = state.state["pypi_version"] # Refresh the version if we need to or just see if we need to warn if pypi_version is None: # Lets use PackageFinder to see what the latest pip version is link_collector = LinkCollector.create( session, options=options, suppress_no_index=True, ) # Pass allow_yanked=False so we don't suggest upgrading to a # yanked version. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=False, # Explicitly set to False ) finder = PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, use_deprecated_html5lib=( "html5lib" in options.deprecated_features_enabled), ) best_candidate = finder.find_best_candidate("pip").best_candidate if best_candidate is None: return pypi_version = str(best_candidate.version) # save that we've performed a check state.save(pypi_version, current_time) remote_version = parse_version(pypi_version) local_version_is_older = ( pip_version < remote_version and pip_version.base_version != remote_version.base_version and was_installed_by_pip("pip")) # Determine if our pypi_version is older if not local_version_is_older: return # We cannot tell how the current pip is available in the current # command context, so be pragmatic here and suggest the command # that's always available. This does not accommodate spaces in # `sys.executable` on purpose as it is not possible to do it # correctly without knowing the user's shell. Thus, # it won't be done until possible through the standard library. # Do not be tempted to use the undocumented subprocess.list2cmdline. # It is considered an internal implementation detail for a reason. pip_cmd = f"{sys.executable} -m pip" logger.warning( "You are using pip version %s; however, version %s is " "available.\nYou should consider upgrading via the " "'%s install --upgrade pip' command.", pip_version, pypi_version, pip_cmd, ) except Exception: logger.debug( "There was an error checking the latest version of pip", exc_info=True, )
def _build_package_finder( self, options, # type: Values session, # type: PipSession target_python=None, # type: Optional[TargetPython] ignore_requires_python=None, # type: Optional[bool] ): # type: (...) -> PackageFinder """ Create a package finder appropriate to this requirement command. :param ignore_requires_python: Whether to ignore incompatible "Requires-Python" values in links. Defaults to False. """ <<<<<<< HEAD link_collector = LinkCollector.create(session, options=options) ======= link_collector = make_link_collector(session, options=options) >>>>>>> b66a76afa15ab74019740676a52a071b85ed8f71 selection_prefs = SelectionPreferences( allow_yanked=True, format_control=options.format_control, allow_all_prereleases=options.pre, prefer_binary=options.prefer_binary, ignore_requires_python=ignore_requires_python, ) return PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, target_python=target_python,
current_time = datetime.datetime.utcnow() # Determine if we need to refresh the state if "last_check" in state.state and "pypi_version" in state.state: last_check = datetime.datetime.strptime( state.state["last_check"], SELFCHECK_DATE_FMT ) if (current_time - last_check).total_seconds() < 7 * 24 * 60 * 60: pypi_version = state.state["pypi_version"] # Refresh the version if we need to or just see if we need to warn if pypi_version is None: # Lets use PackageFinder to see what the latest pip version is link_collector = LinkCollector.create( session, options=options, suppress_no_index=True, ) # Pass allow_yanked=False so we don't suggest upgrading to a # yanked version. selection_prefs = SelectionPreferences( allow_yanked=False, allow_all_prereleases=False, # Explicitly set to False ) finder = PackageFinder.create( link_collector=link_collector, selection_prefs=selection_prefs, ) best_candidate = finder.find_best_candidate("pip").best_candidate