def find_best_match(self, ireq, prereleases=False): if ireq.editable: return ireq versions = ireq.specifier.filter(self.index[key_from_ireq(ireq)], prereleases=prereleases) best_version = max(versions, key=Version) return make_install_requirement(key_from_ireq(ireq), best_version, ireq.extras)
def test_toggle_reuse_hashes_local_repository(capsys, pip_conf, from_line, pypi_repository, reuse_hashes, expected): # Create an install requirement with the hashes included in its options options = { "hashes": { "sha256": [entry.split(":")[1] for entry in NONSENSE] } } req = from_line("small-fake-a==0.1", options=options) existing_pins = {key_from_ireq(req): req} local_repository = LocalRequirementsRepository(existing_pins, pypi_repository, reuse_hashes=reuse_hashes) with local_repository.allow_all_wheels(): assert local_repository.get_hashes( from_line("small-fake-a==0.1")) == expected captured = capsys.readouterr() assert captured.out == "" if reuse_hashes: assert captured.err == "" else: assert (captured.err.strip() == "Couldn't get hashes from PyPI, fallback to hashing files")
def _capture_annotated_out_reqlines(results, resolver, constraints, format_control): with NamedTemporaryFile(delete=False) as tmp_file: tmp_file_name = tmp_file.name try: writer = OutputWriter(src_files=None, dst_file=tmp_file_name, dry_run=False, emit_header=False, emit_index=False, emit_trusted_host=False, annotate=True, generate_hashes=False, default_index_url=None, index_urls=None, trusted_hosts=(), format_control=format_control) writer.write( results=results, reverse_dependencies=resolver.reverse_dependencies(results), unsafe_requirements=resolver.unsafe_constraints, primary_packages={key_from_ireq(ireq) for ireq in constraints}, markers={}, hashes=None) with open(tmp_file_name, 'r') as tmp_file: return tmp_file.readlines() finally: os.unlink(tmp_file_name)
def find_best_match(self, ireq, prereleases=False): if ireq.editable: return ireq versions = list( ireq.specifier.filter( self.index[key_from_ireq(ireq)], prereleases=prereleases ) ) if not versions: tried_versions = [ InstallationCandidate(ireq.name, version, "https://fake.url.foo") for version in self.index[key_from_ireq(ireq)] ] raise NoCandidateFound(ireq, tried_versions, ["https://fake.url.foo"]) best_version = max(versions, key=Version) return make_install_requirement(key_from_ireq(ireq), best_version, ireq)
def find_best_match(self, ireq, prereleases=None): key = key_from_ireq(ireq) existing_pin = self.existing_pins.get(key) if existing_pin and ireq_satisfied_by_existing_pin(ireq, existing_pin): project, version, _ = as_tuple(existing_pin) return make_install_requirement(project, version, ireq) else: return self.repository.find_best_match(ireq, prereleases)
def get_hashes(self, ireq: InstallRequirement) -> Set[str]: existing_pin = self._reuse_hashes and self.existing_pins.get( key_from_ireq(ireq) ) if existing_pin and ireq_satisfied_by_existing_pin(ireq, existing_pin): hashes = existing_pin.hash_options hexdigests = hashes.get(FAVORITE_HASH) if hexdigests: return { ":".join([FAVORITE_HASH, hexdigest]) for hexdigest in hexdigests } return self.repository.get_hashes(ireq)
def get_hashes(self, ireq): key = key_from_ireq(ireq) existing_pin = self.existing_pins.get(key) if existing_pin and ireq_satisfied_by_existing_pin(ireq, existing_pin): hashes = existing_pin.options.get("hashes", {}) hexdigests = hashes.get(FAVORITE_HASH) if hexdigests: return { ":".join([FAVORITE_HASH, hexdigest]) for hexdigest in hexdigests } return self.repository.get_hashes(ireq)
def test_no_upgrades(base_resolver, repository, from_line, input, pins, expected): input = [from_line(line) for line in input] existing_pins = {} for line in pins: ireq = from_line(line) existing_pins[key_from_ireq(ireq)] = ireq local_repository = LocalRequirementsRepository(existing_pins, repository) output = base_resolver(input, prereleases=False, repository=local_repository).resolve() output = {str(line) for line in output} assert output == {str(line) for line in expected}
def test_get_hashes_local_repository_cache_hit(from_line, repository): # Create an install requirement with the hashes included in its options options = { "hashes": { "sha256": [entry.split(":")[1] for entry in EXPECTED] } } req = from_line("small-fake-a==0.1", options=options) existing_pins = {key_from_ireq(req): req} # Use fake repository so that we know the hashes are coming from cache local_repository = LocalRequirementsRepository(existing_pins, repository) with local_repository.allow_all_wheels(): hashes = local_repository.get_hashes(from_line("small-fake-a==0.1")) assert hashes == EXPECTED
def get_hashes(self, ireq): existing_pin = self._reuse_hashes and self.existing_pins.get( key_from_ireq(ireq) ) if existing_pin and ireq_satisfied_by_existing_pin(ireq, existing_pin): if PIP_VERSION[:2] <= (20, 0): hashes = existing_pin.options.get("hashes", {}) else: hashes = existing_pin.hash_options hexdigests = hashes.get(FAVORITE_HASH) if hexdigests: return { ":".join([FAVORITE_HASH, hexdigest]) for hexdigest in hexdigests } return self.repository.get_hashes(ireq)
def test_key_from_ireq_normalization(from_line): keys = set() for line in ("zope.event", "zope-event", "zope_event", "ZOPE.event"): keys.add(key_from_ireq(from_line(line))) assert len(keys) == 1