Method resolve

piptools/resolver.py:245–295

r""" Find concrete package versions for all the given ``InstallRequirement``\ s and their recursive dependencies and return a set of pinned ``InstallRequirement``\ s. Resolves constraints one round at a time, until they don't change anymore. :param m

(self, max_rounds: int = 10)

        )

    def resolve(self, max_rounds: int = 10) -> set[InstallRequirement]:
        r"""
        Find concrete package versions for all the given ``InstallRequirement``\ s
        and their recursive dependencies and return a set of pinned
        ``InstallRequirement``\ s.

        Resolves constraints one round at a time, until they don't change
        anymore.

        :param max_rounds: break out of resolution process after the given number of rounds
            to prevent infinite loops (default is 10)
        """
        if self.clear_caches:
            self.dependency_cache.clear()
            self.repository.clear_caches()

        # Ignore existing packages
        with update_env_context_manager(PIP_EXISTS_ACTION="i"):
            for current_round in count(start=1):  # pragma: no branch
                if current_round > max_rounds:
                    raise RuntimeError(
                        "No stable configuration of concrete packages "
                        "could be found for the given constraints after "
                        "{max_rounds} rounds of resolving.\n"
                        "This is likely a bug.".format(max_rounds=max_rounds)
                    )

                log.debug("")
                log.debug(magenta(f"{f'ROUND {current_round}':^60}"))
                has_changed, best_matches = self._resolve_one_round()
                log.debug("-" * 60)
                log.debug(
                    "Result of round {}: {}".format(
                        current_round,
                        "not stable" if has_changed else "stable, done",
                    )
                )
                if not has_changed:
                    break

        # Only include hard requirements and not pip constraints
        results = {req for req in best_matches if not req.constraint}

        # Filter out unsafe requirements.
        if not self.allow_unsafe:
            self._filter_out_unsafe_constraints(
                ireqs=results,
                unsafe_packages=self.unsafe_packages,
            )

        return results

    def _group_constraints(
        self, constraints: Iterable[InstallRequirement]