def _viable(self, stack, mode, atom, dbs, drop_cycles, limit_to_vdb): """ internal function to discern if an atom is viable, returning the choicepoint/matches iterator if viable. :param stack: current stack :type stack: :obj:`resolver_stack` :param mode: type of dependency (depends/rdepends) :type mode: str :param atom: atom for the current package :type atom: :obj:`pkgcore.ebuild.atom.atom` :param dbs: db list to walk :param drop_cycles: boolean controlling whether to drop dep cycles :param limit_to_vdb: boolean controlling considering pkgs only from the vdb :return: 3 possible; None (not viable), True (presolved), :obj:`caching_iter` (not solved, but viable), :obj:`choice_point` """ choices = ret = None if atom in self.insoluble: ret = ((False, "globally insoluble"),{}) matches = () else: matches = self.state.match_atom(atom) if matches: ret = ((True,), {"pre_solved":True}) else: # not in the plan thus far. matches = caching_iter(dbs.itermatch(atom)) if matches: choices = choice_point(atom, matches) # ignore what dropped out, at this juncture we don't care. choices.reduce_atoms(self.insoluble) if not choices: # and was intractable because it has a hard dep on an # unsolvable atom. ret = ((False, "pruning of insoluble deps " "left no choices"), {}) else: ret = ((False, "no matches"), {}) if choices is None: choices = choice_point(atom, matches) stack.add_frame(mode, atom, choices, dbs, self.state.current_state, drop_cycles, vdb_limited=limit_to_vdb) if not limit_to_vdb and not matches: self.insoluble.add(atom) if ret is not None: self.notify_viable(stack, atom, *ret[0], **ret[1]) if ret[0][0] == True: state.add_backref_op(choices, choices.current_pkg).apply(self.state) return True return None return choices, matches
def _viable(self, stack, mode, atom, dbs, drop_cycles, limit_to_vdb): """ internal function to discern if an atom is viable, returning the choicepoint/matches iter if viable. :return: 3 possible; None (not viable), True (presolved), :obj:`caching_iter` (not solved, but viable), :obj:`choice_point` """ choices = ret = None if atom in self.insoluble: ret = ((False, "globally insoluble"),{}) matches = () else: matches = self.state.match_atom(atom) if matches: ret = ((True,), {"pre_solved":True}) else: # not in the plan thus far. matches = caching_iter(dbs.itermatch(atom)) if matches: choices = choice_point(atom, matches) # ignore what dropped out, at this juncture we don't care. choices.reduce_atoms(self.insoluble) if not choices: # and was intractable because it has a hard dep on an # unsolvable atom. ret = ((False, "pruning of insoluble deps " "left no choices"), {}) else: ret = ((False, "no matches"), {}) if choices is None: choices = choice_point(atom, matches) stack.add_frame(mode, atom, choices, dbs, self.state.current_state, drop_cycles, vdb_limited=limit_to_vdb) if not limit_to_vdb and not matches: self.insoluble.add(atom) if ret is not None: self.notify_viable(stack, atom, *ret[0], **ret[1]) if ret[0][0] == True: state.add_backref_op(choices, choices.current_pkg).apply(self.state) return True return None return choices, matches
def _viable(self, stack, mode, atom, dbs, drop_cycles, limit_to_vdb): """ internal function to discern if an atom is viable, returning the choicepoint/matches iterator if viable. :param stack: current stack :type stack: :obj:`resolver_stack` :param mode: type of dependency (depends/rdepends) :type mode: str :param atom: atom for the current package :type atom: :obj:`pkgcore.ebuild.atom.atom` :param dbs: db list to walk :param drop_cycles: boolean controlling whether to drop dep cycles :param limit_to_vdb: boolean controlling considering pkgs only from the vdb :return: 3 possible; None (not viable), True (presolved), :obj:`caching_iter` (not solved, but viable), :obj:`choice_point` """ choices = ret = None if atom in self.insoluble: ret = ((False, "globally insoluble"), {}) matches = () else: matches = self.state.match_atom(atom) if matches: ret = ((True, ), {"pre_solved": True}) else: # not in the plan thus far. matches = caching_iter(dbs.itermatch(atom)) if matches: choices = choice_point(atom, matches) # ignore what dropped out, at this juncture we don't care. choices.reduce_atoms(self.insoluble) if not choices: # and was intractable because it has a hard dep on an # unsolvable atom. ret = ((False, "pruning of insoluble deps " "left no choices"), {}) else: ret = ((False, "no matches"), {}) if choices is None: choices = choice_point(atom, matches) stack.add_frame(mode, atom, choices, dbs, self.state.current_state, drop_cycles, vdb_limited=limit_to_vdb) if not limit_to_vdb and not matches: self.insoluble.add(atom) if ret is not None: self.notify_viable(stack, atom, *ret[0], **ret[1]) if ret[0][0] == True: state.add_backref_op(choices, choices.current_pkg).apply(self.state) return True return None return choices, matches