improve error messages from resolver

Add better logging and exceptions in the resolver code to convey more
information about what is happening when no match is found.

Log info messages for cases like ignoring all candidate files or having
no candidates at all.

Use standard ResolverException error types and use messages specific to
the different cases for searching for different types of files (sdists
or wheels).

Move all of the logic for checking version compatibility into
is_satisified_by() method of the base class for more consistent logging
via different paths.

Author: dhellmann

src/fromager/resolver.py

@@ -123,9 +123,9 @@ def resolve_from_provider(
     rslvr: resolvelib.Resolver = resolvelib.Resolver(provider, reporter)
     try:
         result = rslvr.resolve([req])
-    except resolvelib.resolvers.exceptions.ResolutionImpossible as err:
+    except resolvelib.resolvers.exceptions.ResolverException as err:
         constraint = provider.constraints.get_constraint(req.name)
-        raise ValueError(
+        raise resolvelib.resolvers.exceptions.ResolverException(
             f"Unable to resolve requirement specifier {req} with constraint {constraint}"
         ) from err
     # resolvelib actually just returns one candidate per requirement.
@@ -142,6 +142,8 @@ def get_project_from_pypi(
     sdist_server_url: str,
 ) -> typing.Iterable[Candidate]:
     """Return candidates created from the project name and extras."""
+    found_candidates: set[str] = set()
+    ignored_candidates: set[str] = set()
     simple_index_url = sdist_server_url.rstrip("/") + "/" + project + "/"
     logger.debug("%s: getting available versions from %s", project, simple_index_url)
     data = session.get(simple_index_url).content
@@ -151,6 +153,7 @@ def get_project_from_pypi(
         py_req = i.attrib.get("data-requires-python")
         path = urlparse(candidate_url).path
         filename = path.rsplit("/", 1)[-1]
+        found_candidates.add(filename)
         if DEBUG_RESOLVER:
             logger.debug("%s: candidate %r -> %r", project, candidate_url, filename)
         # Skip items that need a different Python version
@@ -164,12 +167,14 @@ def get_project_from_pypi(
                     logger.debug(
                         f"{project}: skipping {filename} because of an invalid python version specifier {py_req}: {err}"
                     )
+                ignored_candidates.add(filename)
                 continue
             if PYTHON_VERSION not in spec:
                 if DEBUG_RESOLVER:
                     logger.debug(
                         f"{project}: skipping {filename} because of python version {py_req}"
                     )
+                ignored_candidates.add(filename)
                 continue
 
         # TODO: Handle compatibility tags?
@@ -190,13 +195,15 @@ def get_project_from_pypi(
                 if not matching_tags:
                     if DEBUG_RESOLVER:
                         logger.debug(f"{project}: ignoring {filename} with tags {tags}")
+                    ignored_candidates.add(filename)
                     continue
         except Exception as err:
             # Ignore files with invalid versions
             if DEBUG_RESOLVER:
                 logger.debug(
                     f'{project}: could not determine version for "{filename}": {err}'
                 )
+            ignored_candidates.add(filename)
             continue
         # Look for and ignore cases like `cffi-1.0.2-2.tar.gz` which
         # produces the name `cffi-1-0-2`. We can't just compare the
@@ -208,6 +215,7 @@ def get_project_from_pypi(
         if len(name) != len(project):
             if DEBUG_RESOLVER:
                 logger.debug(f'{project}: skipping invalid filename "{filename}"')
+            ignored_candidates.add(filename)
             continue
 
         c = Candidate(
@@ -224,6 +232,11 @@ def get_project_from_pypi(
             )
         yield c
 
+    if not found_candidates:
+        logger.info(f"{project}: found no candidate files at {simple_index_url}")
+    elif ignored_candidates == found_candidates:
+        logger.info(f"{project}: ignored all candidate files at {simple_index_url}")
+
 
 RequirementsMap: typing.TypeAlias = typing.Mapping[str, typing.Iterable[Requirement]]
 CandidatesMap: typing.TypeAlias = typing.Mapping[str, typing.Iterable[Candidate]]
@@ -273,37 +286,17 @@ def validate_candidate(
     ) -> bool:
         identifier_reqs = list(requirements[identifier])
         bad_versions = {c.version for c in incompatibilities[identifier]}
-        allow_prerelease = self.constraints.allow_prerelease(identifier)
-
         # Skip versions that are known bad
         if candidate.version in bad_versions:
             if DEBUG_RESOLVER:
                 logger.debug(
                     f"{identifier}: skipping bad version {candidate.version} from {bad_versions}"
                 )
             return False
-        # Skip versions that do not match the requirement. Allow prereleases only if constraints allow prereleases
-        if not all(
-            r.specifier.contains(
-                candidate.version,
-                prereleases=(allow_prerelease or bool(r.specifier.prereleases)),
-            )
-            for r in identifier_reqs
-        ):
-            if DEBUG_RESOLVER:
-                logger.debug(
-                    f"{identifier}: skipping {candidate.version} because it does not match {identifier_reqs}"
-                )
-            return False
-        # Skip versions that do not match the constraint
-        if not self.constraints.is_satisfied_by(identifier, candidate.version):
-            if DEBUG_RESOLVER:
-                c = self.constraints.get_constraint(identifier)
-                logger.debug(
-                    f"{identifier}: skipping {candidate.version} due to constraint {c}"
-                )
-            return False
-        return True
+        for r in identifier_reqs:
+            if self.is_satisfied_by(requirement=r, candidate=candidate):
+                return True
+        return False
 
     def get_cache(self) -> dict[str, list[Candidate]]:
         raise NotImplementedError()
@@ -350,9 +343,24 @@ def is_satisfied_by(self, requirement: Requirement, candidate: Candidate) -> boo
         allow_prerelease = self.constraints.allow_prerelease(requirement.name) or bool(
             requirement.specifier.prereleases
         )
-        return requirement.specifier.contains(
+        if not requirement.specifier.contains(
             candidate.version, prereleases=allow_prerelease
-        ) and self.constraints.is_satisfied_by(requirement.name, candidate.version)
+        ):
+            if DEBUG_RESOLVER:
+                logger.debug(
+                    f"{requirement.name}: skipping candidate version {candidate.version} because it does not match {requirement.specifier}"
+                )
+            return False
+
+        if not self.constraints.is_satisfied_by(requirement.name, candidate.version):
+            if DEBUG_RESOLVER:
+                c = self.constraints.get_constraint(requirement.name)
+                logger.debug(
+                    f"{requirement.name}: skipping {candidate.version} due to constraint {c}"
+                )
+            return False
+
+        return True
 
     def get_dependencies(self, candidate: Candidate) -> list[Requirement]:
         # return candidate.dependencies
@@ -437,6 +445,23 @@ def find_matches(
                 ):
                     candidates.append(candidate)
             self.add_to_cache(identifier, candidates)
+        if not candidates:
+            # Try to construct a meaningful error message that points out the
+            # type(s) of files the resolver has been told it can choose as a
+            # hint in case that should be adjusted for the package that does not
+            # resolve.
+            r = next(iter(requirements[identifier]))
+            if self.include_sdists and self.include_wheels:
+                raise resolvelib.resolvers.exceptions.ResolverException(
+                    f"found no match for {r}, any file type, in cache or at {self.sdist_server_url}"
+                )
+            elif self.include_sdists:
+                raise resolvelib.resolvers.exceptions.ResolverException(
+                    f"found no match for {r}, limiting search to sdists, in cache or at {self.sdist_server_url}"
+                )
+            raise resolvelib.resolvers.exceptions.ResolverException(
+                f"found no match for {r}, limiting search to wheels, in cache or at {self.sdist_server_url}"
+            )
         return sorted(candidates, key=attrgetter("version", "build_tag"), reverse=True)
 
 

tests/test_resolver.py

@@ -215,7 +215,7 @@ def test_provider_constraint_mismatch():
         reporter = resolvelib.BaseReporter()
         rslvr = resolvelib.Resolver(provider, reporter)
 
-        with pytest.raises(resolvelib.resolvers.ResolutionImpossible):
+        with pytest.raises(resolvelib.resolvers.exceptions.ResolverException):
             rslvr.resolve([Requirement("hydra-core")])