def test_resolver(provider, base_reporter):
resolver = Resolver(provider, base_reporter)
result = resolver.resolve(provider.root_requirements)
display = {
identifier: candidate.version
for identifier, candidate in result.mapping.items()
}
assert display == provider.expectation
def main(requirements):
reqs = [Requirement(r) for r in requirements]
reporter = BaseReporter()
provider = Provider()
resolver = Resolver(provider, reporter)
state = resolver.resolve(reqs)
target_path = Path("__pypackages__") / PYTHON_VERSION[:3] / "lib"
print("resolution result:")
for k, c in state.mapping.items():
print(c.name, c.version)
for c in state.mapping.values():
c.install(target_path)
def resolve(
resolver: Resolver, requirements: List[Requirement],
requires_python: PySpecSet
) -> Tuple[Dict[str, Candidate], Dict[str, Dict[str, Requirement]], Dict[str,
str]]:
provider, reporter = resolver.provider, resolver.reporter
result = resolver.resolve(requirements)
reporter.extract_metadata()
all_metasets = _calculate_markers_and_pyspecs(
result, provider.requires_python_collection)
mapping = result.mapping
for key, metaset in all_metasets.items():
if key is None:
continue
# Root requires_python doesn't participate in the metaset resolving,
# now check it!
python = requires_python & metaset[1]
if python.is_impossible:
# Candidate doesn't match requires_python constraint
del mapping[key]
else:
candidate = mapping[key]
candidate.marker = join_metaset(metaset)
candidate.hashes = provider.get_hashes(candidate)
return mapping, provider.fetched_dependencies, provider.summary_collection
def resolve(
resolver: Resolver,
requirements: List[Requirement],
requires_python: PySpecSet,
max_rounds: int = 10000,
) -> Tuple[Dict[str, Candidate], Dict[str, List[Requirement]], Dict[str, str]]:
"""Core function to perform the actual resolve process.
Return a tuple containing 3 items:
1. A map of pinned candidates
2. A map of resolved dependencies from each section of pyproject.toml
3. A map of package descriptions fetched from PyPI source.
"""
provider = resolver.provider
result = resolver.resolve(requirements, max_rounds)
mapping = result.mapping
for key, candidate in list(result.mapping.items()):
if key is None:
continue
# Root requires_python doesn't participate in the metaset resolving,
# now check it!
candidate_requires = provider.requires_python_collection[strip_extras(key)[0]]
if (requires_python & candidate_requires).is_impossible:
# Remove candidates that don't match requires_python constraint
del mapping[key]
else:
candidate.requires_python = str(candidate_requires)
candidate.hashes = provider.get_hashes(candidate)
return mapping, provider.fetched_dependencies, provider.summary_collection
def resolve_requirements(
repository,
lines,
requires_python="",
allow_prereleases=None,
strategy="all",
preferred_pins=None,
tracked_names=None,
):
requirements = []
for line in lines:
if line.startswith("-e "):
requirements.append(parse_requirement(line[3:], True))
else:
requirements.append(parse_requirement(line))
requires_python = PySpecSet(requires_python)
if not preferred_pins:
provider = BaseProvider(repository, requires_python, allow_prereleases)
else:
provider_class = (ReusePinProvider
if strategy == "reuse" else EagerUpdateProvider)
provider = provider_class(
preferred_pins,
tracked_names or (),
repository,
requires_python,
allow_prereleases,
)
ui = termui.UI()
with ui.open_spinner("Resolving dependencies") as spin, ui.logging("lock"):
reporter = SpinnerReporter(spin, requirements)
resolver = Resolver(provider, reporter)
mapping, *_ = resolve(resolver, requirements, requires_python)
return mapping
def resolve(
resolver: Resolver,
requirements: list[Requirement],
requires_python: PySpecSet,
max_rounds: int = 10000,
) -> tuple[dict[str, Candidate], dict[str, list[Requirement]]]:
"""Core function to perform the actual resolve process.
Return a tuple containing 3 items:
1. A map of pinned candidates
2. A map of resolved dependencies for each dependency group
3. A map of package descriptions fetched from PyPI source
"""
requirements.append(PythonRequirement.from_pyspec_set(requires_python))
provider = cast(BaseProvider, resolver.provider)
result = resolver.resolve(requirements, max_rounds)
mapping = cast(Dict[str, Candidate], result.mapping)
mapping.pop("python", None)
for key, candidate in list(result.mapping.items()):
if key is None:
continue
# For source distribution whose name can only be determined after it is built,
# the key in the resolution map should be updated.
if key.startswith(":empty:"):
new_key = provider.identify(candidate)
mapping[new_key] = mapping.pop(key)
key = new_key
candidate.hashes = provider.repository.get_hashes(candidate)
return mapping, provider.fetched_dependencies
def resolve_func(
lines,
requires_python="",
allow_prereleases=None,
strategy="all",
tracked_names=None,
):
repository.environment.python_requires = PySpecSet(requires_python)
if allow_prereleases is not None:
project.tool_settings["allow_prereleases"] = allow_prereleases
requirements = []
for line in lines:
if line.startswith("-e "):
requirements.append(parse_requirement(line[3:], True))
else:
requirements.append(parse_requirement(line))
provider = project.get_provider(strategy, tracked_names)
ui = project.core.ui
with ui.open_spinner("Resolving dependencies") as spin, ui.logging(
"lock"):
reporter = SpinnerReporter(spin, requirements)
resolver = Resolver(provider, reporter)
mapping, *_ = _resolve(resolver, requirements,
repository.environment.python_requires)
return mapping
def resolve(
resolver: Resolver,
requirements: List[Requirement],
requires_python: PySpecSet,
max_rounds: int = 1000,
) -> Tuple[Dict[str, Candidate], Dict[str, List[Requirement]], Dict[str, str]]:
"""Core function to perform the actual resolve process.
Return a tuple containing 3 items:
1. A map of pinned candidates
2. A map of resolved dependencies from each section of pyproject.toml
3. A map of package descriptions fetched from PyPI source.
"""
provider, reporter = resolver.provider, resolver.reporter
result = resolver.resolve(requirements, max_rounds)
reporter.extract_metadata()
all_metasets = extract_metadata(result)
mapping = result.mapping
for key, metaset in all_metasets.items():
if key is None:
continue
# Root requires_python doesn't participate in the metaset resolving,
# now check it!
python = (
requires_python
& metaset.requires_python
& provider.requires_python_collection[strip_extras(key)[0]]
)
if python.is_impossible:
# Candidate doesn't match requires_python constraint
del mapping[key]
else:
candidate = mapping[key]
candidate.marker = metaset.as_marker()
candidate.hashes = provider.get_hashes(candidate)
populate_sections(result)
return mapping, provider.fetched_dependencies, provider.summary_collection
def resolve(
resolver: Resolver,
requirements: list[Requirement],
requires_python: PySpecSet,
max_rounds: int = 10000,
) -> tuple[dict[str, Candidate], dict[str, list[Requirement]], dict[str, str]]:
"""Core function to perform the actual resolve process.
Return a tuple containing 3 items:
1. A map of pinned candidates
2. A map of resolved dependencies for each dependency group
3. A map of package descriptions fetched from PyPI source
"""
provider = cast(BaseProvider, resolver.provider)
result = resolver.resolve(requirements, max_rounds)
mapping = cast(Dict[str, Candidate], result.mapping)
for key, candidate in list(result.mapping.items()):
if key is None:
continue
# For source distribution whose name can only be determined after it is built,
# the key in the resolution map should be updated.
if key.startswith(":empty:"):
new_key = provider.identify(candidate)
mapping[new_key] = mapping.pop(key)
key = new_key
# Root requires_python doesn't participate in the metaset resolving,
# now check it!
candidate_requires = provider.requires_python_collection[strip_extras(
key)[0]]
if (requires_python & candidate_requires).is_impossible:
# Remove candidates that don't match requires_python constraint
del mapping[key]
else:
candidate.requires_python = str(candidate_requires)
candidate.hashes = provider.get_hashes(candidate)
return mapping, provider.fetched_dependencies, provider.summary_collection
def test_resolver(provider, reporter):
resolver = Resolver(provider, reporter)
result = resolver.resolve(provider.root_requirements)
assert _format_resolution(result) == provider.expected_resolution