Use available versions to simplify unsat error reports (#547)

Uses pubgrub-rs/pubgrub#156 to consolidate
version ranges in error reports using the actual available versions for
each package.

Alternative to astral-sh/pubgrub#8 which implements
this behavior as a method in the `Reporter` — here it's implemented in
our custom report formatter (#521) instead which requires no upstream
changes.

Requires astral-sh/pubgrub#11 to only retrieve the
versions for packages that will be used in the report.

This is a work in progress. Some things to do:
- ~We may want to allow lazy retrieval of the version maps from the
formatter~
- [x] We should probably create a separate error type for no solution
instead of mixing them with other resolve errors
- ~We can probably do something smarter than creating vectors to hold
the versions~
- [x] This degrades error messages when a single version is not
available, we'll need to special case that
- [x] It seems safer to coerce the error type in `resolve` instead of
`solve` if feasible

Cargo.toml

@@ -51,7 +51,7 @@ once_cell = { version = "1.18.0" }
 petgraph = { version = "0.6.4" }
 platform-info = { version = "2.0.2" }
 plist = { version = "1.6.0" }
-pubgrub = { git = "https:/zanieb/pubgrub", rev = "a1d584a5e506b8f0a600269373190c4a35b298d5" }
+pubgrub = { git = "https:/zanieb/pubgrub", rev = "8fff95d6a233a9fa4ee5ab5429033f0f0d3ddb20" }
 pyo3 = { version = "0.20.0" }
 pyo3-log = { version = "0.9.0"}
 pyproject-toml = { version = "0.8.0" }

crates/puffin-cli/src/commands/pip_compile.rs

@@ -152,7 +152,7 @@ pub(crate) async fn pip_compile(
  let resolver = Resolver::new(manifest, options, &markers, &tags, &client, &build_dispatch)
  .with_reporter(ResolverReporter::from(printer));
  let resolution = match resolver.resolve().await {
- Err(puffin_resolver::ResolveError::PubGrub(err)) => {
+ Err(puffin_resolver::ResolveError::NoSolution(err)) => {
  #[allow(clippy::print_stderr)]
  {
  let report = miette::Report::msg(format!("{err}"))

crates/puffin-cli/src/commands/pip_install.rs

@@ -237,14 +237,14 @@ async fn resolve(
  let resolver = Resolver::new(manifest, options, markers, &tags, &client, &build_dispatch)
  .with_reporter(ResolverReporter::from(printer));
  let resolution = match resolver.resolve().await {
- Err(puffin_resolver::ResolveError::PubGrub(err)) => {
+ Err(puffin_resolver::ResolveError::NoSolution(err)) => {
  #[allow(clippy::print_stderr)]
  {
  let report = miette::Report::msg(format!("{err}"))
  .context("No solution found when resolving dependencies:");
  eprint!("{report:?}");
  }
- return Err(puffin_resolver::ResolveError::PubGrub(err).into());
+ return Err(puffin_resolver::ResolveError::NoSolution(err).into());
  }
  result => result,
  }?;

crates/puffin-resolver/src/error.rs

@@ -1,16 +1,20 @@
 use std::fmt::Formatter;
 
 use pubgrub::range::Range;
-use pubgrub::report::{DefaultStringReporter, Reporter};
+use pubgrub::report::{DefaultStringReporter, DerivationTree, Reporter};
+use pypi_types::IndexUrl;
+use rustc_hash::FxHashMap;
 use thiserror::Error;
 use url::Url;
 
 use distribution_types::{BuiltDist, PathBuiltDist, PathSourceDist, SourceDist};
 use pep508_rs::Requirement;
 use puffin_distribution::DistributionDatabaseError;
 use puffin_normalize::PackageName;
+use puffin_traits::OnceMap;
 
 use crate::pubgrub::{PubGrubPackage, PubGrubVersion};
+use crate::version_map::VersionMap;
 use crate::PubGrubReportFormatter;
 
 #[derive(Error, Debug)]
@@ -30,9 +34,6 @@ pub enum ResolveError {
  #[error(transparent)]
  Join(#[from] tokio::task::JoinError),
 
- #[error(transparent)]
- PubGrub(#[from] RichPubGrubError),
-
  #[error("Package metadata name `{metadata}` does not match given name `{given}`")]
  NameMismatch {
  given: PackageName,
@@ -65,6 +66,37 @@ pub enum ResolveError {
 
  #[error("Failed to build: {0}")]
  Build(Box<PathSourceDist>, #[source] DistributionDatabaseError),
+
+ #[error(transparent)]
+ NoSolution(#[from] NoSolutionError),
+
+ #[error("Retrieving dependencies of {package} {version} failed")]
+ ErrorRetrievingDependencies {
+ /// Package whose dependencies we want.
+ package: Box<PubGrubPackage>,
+ /// Version of the package for which we want the dependencies.
+ version: Box<PubGrubVersion>,
+ /// Error raised by the implementer of [DependencyProvider](crate::solver::DependencyProvider).
+ source: Box<dyn std::error::Error + Send + Sync>,
+ },
+
+ #[error("{package} {version} depends on itself")]
+ SelfDependency {
+ /// Package whose dependencies we want.
+ package: Box<PubGrubPackage>,
+ /// Version of the package for which we want the dependencies.
+ version: Box<PubGrubVersion>,
+ },
+
+ #[error("Decision making failed")]
+ ErrorChoosingPackageVersion(Box<dyn std::error::Error + Send + Sync>),
+
+ #[error("We should cancel")]
+ ErrorInShouldCancel(Box<dyn std::error::Error + Send + Sync>),
+
+ /// Something unexpected happened.
+ #[error("{0}")]
+ Failure(String),
 }
 
 impl<T> From<futures::channel::mpsc::TrySendError<T>> for ResolveError {
@@ -73,28 +105,83 @@ impl<T> From<futures::channel::mpsc::TrySendError<T>> for ResolveError {
  }
 }
 
-/// A wrapper around [`pubgrub::error::PubGrubError`] that displays a resolution failure report.
+impl From<pubgrub::error::PubGrubError<PubGrubPackage, Range<PubGrubVersion>>> for ResolveError {
+ fn from(value: pubgrub::error::PubGrubError<PubGrubPackage, Range<PubGrubVersion>>) -> Self {
+ match value {
+ pubgrub::error::PubGrubError::ErrorChoosingPackageVersion(inner) => {
+ ResolveError::ErrorChoosingPackageVersion(inner)
+ }
+ pubgrub::error::PubGrubError::ErrorInShouldCancel(inner) => {
+ ResolveError::ErrorInShouldCancel(inner)
+ }
+ pubgrub::error::PubGrubError::ErrorRetrievingDependencies {
+ package,
+ version,
+ source,
+ } => ResolveError::ErrorRetrievingDependencies {
+ package: Box::new(package),
+ version: Box::new(version),
+ source,
+ },
+ pubgrub::error::PubGrubError::Failure(inner) => ResolveError::Failure(inner),
+ pubgrub::error::PubGrubError::NoSolution(derivation_tree) => {
+ ResolveError::NoSolution(NoSolutionError {
+ derivation_tree,
+ available_versions: FxHashMap::default(),
+ })
+ }
+ pubgrub::error::PubGrubError::SelfDependency { package, version } => {
+ ResolveError::SelfDependency {
+ package: Box::new(package),
+ version: Box::new(version),
+ }
+ }
+ }
+ }
+}
+
+/// A wrapper around [`pubgrub::error::PubGrubError::NoSolution`] that displays a resolution failure report.
 #[derive(Debug)]
-pub struct RichPubGrubError {
- source: pubgrub::error::PubGrubError<PubGrubPackage, Range<PubGrubVersion>>,
+pub struct NoSolutionError {
+ derivation_tree: DerivationTree<PubGrubPackage, Range<PubGrubVersion>>,
+ available_versions: FxHashMap<PubGrubPackage, Vec<PubGrubVersion>>,
 }
 
-impl std::error::Error for RichPubGrubError {}
+impl std::error::Error for NoSolutionError {}
 
-impl std::fmt::Display for RichPubGrubError {
+impl std::fmt::Display for NoSolutionError {
  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
- if let pubgrub::error::PubGrubError::NoSolution(derivation_tree) = &self.source {
- let formatter = PubGrubReportFormatter;
- let report = DefaultStringReporter::report_with_formatter(derivation_tree, &formatter);
- write!(f, "{report}")
- } else {
- write!(f, "{}", self.source)
- }
+ let formatter = PubGrubReportFormatter {
+ available_versions: &self.available_versions,
+ };
+ let report =
+ DefaultStringReporter::report_with_formatter(&self.derivation_tree, &formatter);
+ write!(f, "{report}")
  }
 }
 
-impl From<pubgrub::error::PubGrubError<PubGrubPackage, Range<PubGrubVersion>>> for ResolveError {
- fn from(value: pubgrub::error::PubGrubError<PubGrubPackage, Range<PubGrubVersion>>) -> Self {
- ResolveError::PubGrub(RichPubGrubError { source: value })
+impl NoSolutionError {
+ /// Update the available versions attached to the error using the given package version index.
+ ///
+ /// Only packages used in the error's deriviation tree will be retrieved.
+ pub(crate) fn update_available_versions(
+ mut self,
+ package_versions: &OnceMap<PackageName, (IndexUrl, VersionMap)>,
+ ) -> Self {
+ for package in self.derivation_tree.packages() {
+ if let PubGrubPackage::Package(name, ..) = package {
+ if let Some(entry) = package_versions.get(name) {
+ let (_, version_map) = entry.value();
+ self.available_versions.insert(
+ package.clone(),
+ version_map
+ .iter()
+ .map(|(version, _)| version.clone())
+ .collect(),
+ );
+ }
+ }
+ }
+ self
  }
 }

crates/puffin-resolver/src/pubgrub/report.rs

@@ -2,13 +2,32 @@ use pubgrub::range::Range;
 use pubgrub::report::{External, ReportFormatter};
 use pubgrub::term::Term;
 use pubgrub::type_aliases::Map;
+use rustc_hash::FxHashMap;
 
 use super::{PubGrubPackage, PubGrubVersion};
 
-#[derive(Debug, Default)]
-pub struct PubGrubReportFormatter;
+#[derive(Debug)]
+pub struct PubGrubReportFormatter<'a> {
+ /// The versions that were available for each package
+ pub available_versions: &'a FxHashMap<PubGrubPackage, Vec<PubGrubVersion>>,
+}
+
+impl PubGrubReportFormatter<'_> {
+ fn simplify_set(
+ &self,
+ set: &Range<PubGrubVersion>,
+ package: &PubGrubPackage,
+ ) -> Range<PubGrubVersion> {
+ set.simplify(
+ self.available_versions
+ .get(package)
+ .unwrap_or(&vec![])
+ .iter(),
+ )
+ }
+}
 
-impl ReportFormatter<PubGrubPackage, Range<PubGrubVersion>> for PubGrubReportFormatter {
+impl ReportFormatter<PubGrubPackage, Range<PubGrubVersion>> for PubGrubReportFormatter<'_> {
  type Output = String;
 
  fn format_external(
@@ -23,13 +42,15 @@ impl ReportFormatter<PubGrubPackage, Range<PubGrubVersion>> for PubGrubReportFor
  if set == &Range::full() {
  format!("there is no available version for {package}")
  } else {
+ let set = self.simplify_set(set, package);
  format!("there is no version of {package} available matching {set}")
  }
  }
  External::UnavailableDependencies(package, set) => {
  if set == &Range::full() {
  format!("dependencies of {package} are unavailable")
  } else {
+ let set = self.simplify_set(set, package);
  format!("dependencies of {package} at version {set} are unavailable")
  }
  }
@@ -41,13 +62,15 @@ impl ReportFormatter<PubGrubPackage, Range<PubGrubVersion>> for PubGrubReportFor
  if set == &Range::full() {
  format!("dependencies of {package} are unusable: {reason}")
  } else {
+ let set = self.simplify_set(set, package);
  format!("dependencies of {package}{set} are unusable: {reason}",)
  }
  }
  } else {
  if set == &Range::full() {
  format!("dependencies of {package} are unusable")
  } else {
+ let set = self.simplify_set(set, package);
  format!("dependencies of {package}{set} are unusable")
  }
  }
@@ -56,19 +79,23 @@ impl ReportFormatter<PubGrubPackage, Range<PubGrubVersion>> for PubGrubReportFor
  if package_set == &Range::full() && dependency_set == &Range::full() {
  format!("{package} depends on {dependency}")
  } else if package_set == &Range::full() {
+ let dependency_set = self.simplify_set(dependency_set, package);
  format!("{package} depends on {dependency}{dependency_set}")
  } else if dependency_set == &Range::full() {
  if matches!(package, PubGrubPackage::Root(_)) {
  // Exclude the dummy version for root packages
  format!("{package} depends on {dependency}")
  } else {
+ let package_set = self.simplify_set(package_set, package);
  format!("{package}{package_set} depends on {dependency}")
  }
  } else {
+ let dependency_set = self.simplify_set(dependency_set, package);
  if matches!(package, PubGrubPackage::Root(_)) {
  // Exclude the dummy version for root packages
  format!("{package} depends on {dependency}{dependency_set}")
  } else {
+ let package_set = self.simplify_set(package_set, package);
  format!("{package}{package_set} depends on {dependency}{dependency_set}")
  }
  }
@@ -82,9 +109,21 @@ impl ReportFormatter<PubGrubPackage, Range<PubGrubVersion>> for PubGrubReportFor
  match terms_vec.as_slice() {
  [] | [(PubGrubPackage::Root(_), _)] => "version solving failed".into(),
  [(package @ PubGrubPackage::Package(..), Term::Positive(range))] => {
+ let range = range.simplify(
+ self.available_versions
+ .get(package)
+ .unwrap_or(&vec![])
+ .iter(),
+ );
  format!("{package}{range} is forbidden")
  }
  [(package @ PubGrubPackage::Package(..), Term::Negative(range))] => {
+ let range = range.simplify(
+ self.available_versions
+ .get(package)
+ .unwrap_or(&vec![])
+ .iter(),
+ );
  format!("{package}{range} is mandatory")
  }
  [(p1, Term::Positive(r1)), (p2, Term::Negative(r2))] => self.format_external(

crates/puffin-resolver/src/resolver.rs

@@ -247,7 +247,14 @@ impl<'a, Provider: ResolverProvider> Resolver<'a, Provider> {
  return Err(ResolveError::StreamTermination);
  }
  resolution = resolve_fut => {
- resolution?
+ resolution.map_err(|err| {
+ // Add version information to improve unsat error messages
+ if let ResolveError::NoSolution(err) = err {
+ ResolveError::NoSolution(err.update_available_versions(&self.index.packages))
+ } else {
+ err
+ }
+ })?
  }
  };