def _add_package_rules(self, package):
"""
Create all the rules required to satisfy installing the given package.
"""
work_queue = collections.deque()
work_queue.append(package)
while len(work_queue) > 0:
p = work_queue.popleft()
p_id = self._pool.package_id(p)
if p_id not in self.added_package_ids:
self.added_package_ids.add(p_id)
self._add_dependencies_rules(p, work_queue)
requirement = Requirement.from_legacy_requirement_string(
p.name)
obsolete_providers = self._pool.what_provides(requirement)
for provider in obsolete_providers:
if provider != p:
if provider.name == p.name:
reason = RuleType.package_same_name
else:
reason = RuleType.package_implicit_obsoletes
rule = self._create_conflicts_rule(
p, provider, reason, str(p))
self._add_rule(rule, "package")
def _add_package_rules(self, package):
"""
Create all the rules required to satisfy installing the given package.
"""
work_queue = collections.deque()
work_queue.append(package)
while len(work_queue) > 0:
p = work_queue.popleft()
p_id = self._pool.package_id(p)
if p_id not in self.added_package_ids:
self.added_package_ids.add(p_id)
self._add_dependencies_rules(p, work_queue)
requirement = Requirement.from_legacy_requirement_string(p.name)
obsolete_providers = self._pool.what_provides(requirement)
for provider in obsolete_providers:
if provider != p:
if provider.name == p.name:
reason = RuleType.package_same_name
else:
reason = RuleType.package_implicit_obsoletes
rule = self._create_conflicts_rule(p, provider,
reason, str(p))
self._add_rule(rule, "package")
def dependency_to_string(dependency):
req = Requirement.from_legacy_requirement_string(dependency)
constraints = list(req._constraints._constraints)
assert len(constraints) == 1
assert isinstance(constraints[0], (EnpkgUpstreamMatch, Any, Equal))
constraint = constraints[0]
if isinstance(constraint, Any):
return req.name
elif isinstance(constraint, Equal):
return "{0} == {1}".format(req.name, str(constraint.version))
else: # EnpkgUpstreamMatch
assert isinstance(constraint.version, EnpkgVersion)
return "{0} ~= {1}".format(req.name, str(constraint.version.upstream))
def dependency_to_string(dependency):
req = Requirement.from_legacy_requirement_string(dependency)
constraints = list(req._constraints._constraints)
assert len(constraints) == 1
assert isinstance(constraints[0],
(EnpkgUpstreamMatch, Any, Equal))
constraint = constraints[0]
if isinstance(constraint, Any):
return req.name
elif isinstance(constraint, Equal):
return "{0} == {1}".format(req.name, str(constraint.version))
else: # EnpkgUpstreamMatch
assert isinstance(constraint.version, EnpkgVersion)
return "{0} ~= {1}".format(req.name, str(constraint.version.upstream))
def _add_dependencies_rules(self, package, work_queue):
for dependency in package.dependencies:
requirement = Requirement.from_legacy_requirement_string(dependency)
dependency_candidates = self._pool.what_provides(requirement)
assert len(dependency_candidates) > 0, \
("No candidates found for requirement {0!r}, needed for "
"dependency {1!r}".format(requirement.name, package))
rule = self._create_dependency_rule(package, dependency_candidates,
RuleType.package_requires,
str(dependency))
self._add_rule(rule, "package")
for candidate in dependency_candidates:
work_queue.append(candidate)
def _add_dependencies_rules(self, package, work_queue):
for dependency in package.dependencies:
requirement = Requirement.from_legacy_requirement_string(
dependency)
dependency_candidates = self._pool.what_provides(requirement)
assert len(dependency_candidates) > 0, \
("No candidates found for requirement {0!r}, needed for "
"dependency {1!r}".format(requirement.name, package))
rule = self._create_dependency_rule(package, dependency_candidates,
RuleType.package_requires,
str(dependency))
self._add_rule(rule, "package")
for candidate in dependency_candidates:
work_queue.append(candidate)
def optimize_at_level(pool, parent_package, rules, solution):
new_rules = rules[:]
# Step 1: optimize each dependency independently
best_dependencies = []
for dependency in parent_package.dependencies:
requirement = Requirement.from_legacy_requirement_string(dependency)
best_candidate = find_best_candidate(pool, requirement, new_rules)
new_rules.append(PackageRule((best_candidate.id,)))
best_dependencies.append(best_candidate)
solution.extend(best_dependencies)
# Step 2: recurse
for dependency in best_dependencies:
solution = optimize_at_level(pool, dependency, new_rules, solution)
return solution
def legacy_dependencies_to_pretty_string(dependencies):
""" Convert a sequence of legacy dependency strings to a pretty constraint
string.
Parameters
----------
dependencies : seq
Sequence of legacy dependency string (e.g. 'MKL 10.3')
"""
constraints_mapping = []
for dependency in dependencies:
req = Requirement.from_legacy_requirement_string(dependency)
constraints = req._constraints._constraints
assert len(constraints) == 1
constraint = next(iter(constraints))
assert isinstance(constraint,
(EnpkgUpstreamMatch, Any, Equal))
constraints_mapping.append((req.name, frozenset((constraint,))))
return constraints_to_pretty_string(constraints_mapping)
