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)