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(
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]]]:
"""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 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,
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