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
