refactor(resolver): use provider pattern directly in resolution layer

Replace intermediate resolution functions with direct provider usage:
- RequirementResolver now calls resolve_from_provider() directly
- sources.resolve_source() uses get_resolver_provider plugin hook
- wheels.resolve_prebuilt_wheel() uses get_resolver_provider plugin hook
- Removed resolve_all() methods per architect guidance

This refactoring simplifies the resolution architecture by eliminating
the intermediate *_all() function layer while maintaining all existing
functionality. All resolution now goes through the provider pattern
with overrides.find_and_invoke() + resolver.resolve_from_provider().

Tests updated to match new implementation.

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>
Signed-off-by: Rohan Devasthale <[email protected]>

Author: rd4398

src/fromager/bootstrapper.py

@@ -176,7 +176,7 @@ def resolve_version(
     ) -> tuple[str, Version]:
         """Resolve the version of a requirement.
 
-        Returns the source URL and the version of the requirement.
+        Returns the source URL and the version of the requirement (highest matching version).
 
         Git URL resolution stays in Bootstrapper because it requires
         build orchestration (BuildEnvironment, build dependencies).
@@ -193,19 +193,22 @@ def resolve_version(
             cached_result = self._resolver.get_cached_resolution(req, pre_built=False)
             if cached_result is not None:
                 logger.debug(f"resolved {req} from cache")
-                return cached_result
+                # Pick highest version from cached list
+                return cached_result[0]
 
             logger.info("resolving source via URL, ignoring any plugins")
             source_url, resolved_version = self._resolve_version_from_git_url(req=req)
             # Cache the git URL resolution (always source, not prebuilt)
+            # Store as list for consistency with cache structure
             self._resolver.cache_resolution(
-                req, pre_built=False, result=(source_url, resolved_version)
+                req, pre_built=False, result=[(source_url, resolved_version)]
             )
             return source_url, resolved_version
 
         # Delegate to RequirementResolver
         parent_req = self.why[-1][1] if self.why else None
 
+        # Returns the highest matching version
         return self._resolver.resolve(
             req=req,
             req_type=req_type,

src/fromager/requirement_resolver.py

@@ -12,7 +12,7 @@
 from packaging.requirements import Requirement
 from packaging.version import Version
 
-from . import resolver, sources, wheels
+from . import overrides, resolver
 from .dependency_graph import DependencyGraph
 from .requirements_file import RequirementType
 
@@ -51,7 +51,10 @@ def __init__(
         self.prev_graph = prev_graph
         # Session-level resolution cache to avoid re-resolving same requirements
         # Key: (requirement_string, pre_built) to distinguish source vs prebuilt
-        self._resolved_requirements: dict[tuple[str, bool], tuple[str, Version]] = {}
+        # Value: list of (url, version) tuples sorted by version (highest first)
+        self._resolved_requirements: dict[
+            tuple[str, bool], list[tuple[str, Version]]
+        ] = {}
 
     def resolve(
         self,
@@ -60,7 +63,7 @@ def resolve(
         parent_req: Requirement | None = None,
         pre_built: bool | None = None,
     ) -> tuple[str, Version]:
-        """Resolve package requirement.
+        """Resolve package requirement to the best matching version.
 
         Tries resolution strategies in order:
         1. Session cache (if previously resolved)
@@ -75,7 +78,7 @@ def resolve(
                 If None (default), uses package build info to determine.
 
         Returns:
-            Tuple of (url, resolved_version)
+            (url, version) tuple for the highest matching version
 
         Raises:
             ValueError: If req contains a git URL and pre_built is False
@@ -98,23 +101,22 @@ def resolve(
         cached_result = self.get_cached_resolution(req, pre_built)
         if cached_result is not None:
             logger.debug(f"resolved {req} from cache")
-            return cached_result
+            return cached_result[0]
 
         # Resolve using strategies
-        url, resolved_version = self._resolve(req, req_type, parent_req, pre_built)
+        results = self._resolve(req, req_type, parent_req, pre_built)
 
         # Cache the result
-        result = (url, resolved_version)
-        self.cache_resolution(req, pre_built, result)
-        return url, resolved_version
+        self.cache_resolution(req, pre_built, results)
+        return results[0]
 
     def _resolve(
         self,
         req: Requirement,
         req_type: RequirementType,
         parent_req: Requirement | None,
         pre_built: bool,
-    ) -> tuple[str, Version]:
+    ) -> list[tuple[str, Version]]:
         """Internal resolution logic without caching.
 
         Tries resolution strategies in order:
@@ -128,7 +130,7 @@ def _resolve(
             pre_built: Whether to resolve prebuilt (True) or source (False)
 
         Returns:
-            Tuple of (url, resolved_version)
+            List of (url, version) tuples sorted by version (highest first)
         """
         # Try graph
         cached_resolution = self._resolve_from_graph(
@@ -139,43 +141,81 @@ def _resolve(
         )
 
         if cached_resolution and not req.url:
-            url, resolved_version = cached_resolution
-            logger.debug(f"resolved from previous bootstrap to {resolved_version}")
-            return url, resolved_version
+            logger.debug(
+                f"resolved from previous bootstrap: {len(cached_resolution)} version(s)"
+            )
+            return cached_resolution
+
+        # Fallback to PyPI using provider pattern
+        pbi = self.ctx.package_build_info(req)
 
-        # Fallback to PyPI
         if pre_built:
             # Resolve prebuilt wheel
-            servers = wheels.get_wheel_server_urls(
-                self.ctx, req, cache_wheel_server_url=resolver.PYPI_SERVER_URL
-            )
-            url, resolved_version = wheels.resolve_prebuilt_wheel(
-                ctx=self.ctx, req=req, wheel_server_urls=servers, req_type=req_type
+            # Get wheel server URLs
+            wheel_server_urls: list[str] = []
+            if pbi.wheel_server_url:
+                wheel_server_urls.append(pbi.wheel_server_url)
+            else:
+                if self.ctx.wheel_server_url:
+                    wheel_server_urls.append(self.ctx.wheel_server_url)
+                wheel_server_urls.append(resolver.PYPI_SERVER_URL)
+
+            # Try each wheel server until one succeeds
+            for url in wheel_server_urls:
+                try:
+                    provider = overrides.find_and_invoke(
+                        req.name,
+                        "get_resolver_provider",
+                        resolver.default_resolver_provider,
+                        ctx=self.ctx,
+                        req=req,
+                        include_sdists=False,
+                        include_wheels=True,
+                        sdist_server_url=url,
+                        req_type=req_type,
+                        ignore_platform=False,
+                    )
+                    results = resolver.resolve_from_provider(provider, req)
+                    if results:
+                        return results
+                except Exception:
+                    continue
+            # If we get here, no wheel server succeeded
+            raise ValueError(
+                f"Could not find a prebuilt wheel for {req} on {' or '.join(wheel_server_urls)}"
             )
         else:
             # Resolve source (sdist)
-            url, resolved_version = sources.resolve_source(
+            override_sdist_server_url = pbi.resolver_sdist_server_url(
+                resolver.PYPI_SERVER_URL
+            )
+            provider = overrides.find_and_invoke(
+                req.name,
+                "get_resolver_provider",
+                resolver.default_resolver_provider,
                 ctx=self.ctx,
                 req=req,
-                sdist_server_url=resolver.PYPI_SERVER_URL,
+                include_sdists=pbi.resolver_include_sdists,
+                include_wheels=pbi.resolver_include_wheels,
+                sdist_server_url=override_sdist_server_url,
                 req_type=req_type,
+                ignore_platform=pbi.resolver_ignore_platform,
             )
-
-        return url, resolved_version
+            return resolver.resolve_from_provider(provider, req)
 
     def get_cached_resolution(
         self,
         req: Requirement,
         pre_built: bool,
-    ) -> tuple[str, Version] | None:
+    ) -> list[tuple[str, Version]] | None:
         """Get a cached resolution result if it exists.
 
         Args:
             req: Package requirement to look up in cache
             pre_built: Whether looking for prebuilt or source resolution
 
         Returns:
-            Tuple of (source_url, resolved_version) if cached, None otherwise
+            List of (url, version) tuples if cached, None otherwise
         """
         cache_key = (str(req), pre_built)
         return self._resolved_requirements.get(cache_key)
@@ -184,7 +224,7 @@ def cache_resolution(
         self,
         req: Requirement,
         pre_built: bool,
-        result: tuple[str, Version],
+        result: list[tuple[str, Version]],
     ) -> None:
         """Cache a resolution result.
 
@@ -194,7 +234,7 @@ def cache_resolution(
         Args:
             req: Package requirement to cache
             pre_built: Whether this is a prebuilt or source resolution
-            result: Tuple of (source_url, resolved_version)
+            result: List of (url, version) tuples
         """
         cache_key = (str(req), pre_built)
         self._resolved_requirements[cache_key] = result
@@ -205,7 +245,7 @@ def _resolve_from_graph(
         req_type: RequirementType,
         pre_built: bool,
         parent_req: Requirement | None,
-    ) -> tuple[str, Version] | None:
+    ) -> list[tuple[str, Version]] | None:
         """Resolve from previous dependency graph.
 
         Extracted from Bootstrapper._resolve_from_graph().
@@ -217,7 +257,7 @@ def _resolve_from_graph(
             parent_req: Parent requirement for graph traversal
 
         Returns:
-            Tuple of (url, version) if found in graph, None otherwise
+            List of (url, version) tuples if found in graph, None otherwise
         """
         if not self.prev_graph:
             return None
@@ -307,8 +347,8 @@ def _resolve_from_version_source(
         self,
         version_source: list[tuple[str, Version]],
         req: Requirement,
-    ) -> tuple[str, Version] | None:
-        """Select best version from candidates.
+    ) -> list[tuple[str, Version]] | None:
+        """Filter and return all matching versions from candidates.
 
         Extracted from Bootstrapper._resolve_from_version_source().
 
@@ -317,7 +357,7 @@ def _resolve_from_version_source(
             req: Package requirement with version specifier
 
         Returns:
-            Tuple of (url, version) for best match, None if no match
+            List of (url, version) tuples for all matches, None if no matches
         """
         if not version_source:
             return None
@@ -329,6 +369,7 @@ def _resolve_from_version_source(
                 constraints=self.ctx.constraints,
                 use_resolver_cache=False,
             )
+            # resolve_from_provider now returns all matching candidates
             return resolver.resolve_from_provider(provider, req)
         except Exception as err:
             logger.debug(f"could not resolve {req} from {version_source}: {err}")

src/fromager/resolver.py

@@ -86,6 +86,10 @@ def resolve(
     req_type: RequirementType | None = None,
     ignore_platform: bool = False,
 ) -> tuple[str, Version]:
+    """Resolve requirement and return the best matching version.
+
+    Returns (url, version) tuple for the highest matching version.
+    """
     # Create the (reusable) resolver.
     provider = overrides.find_and_invoke(
         req.name,
@@ -99,7 +103,8 @@ def resolve(
         req_type=req_type,
         ignore_platform=ignore_platform,
     )
-    return resolve_from_provider(provider, req)
+    results = resolve_from_provider(provider, req)
+    return results[0]
 
 
 def default_resolver_provider(
@@ -165,26 +170,31 @@ def ending(self, state: typing.Any) -> None:
 
 def resolve_from_provider(
     provider: BaseProvider, req: Requirement
-) -> tuple[str, Version]:
-    reporter = LogReporter(req)
-    rslvr: resolvelib.Resolver = resolvelib.Resolver(provider, reporter)
+) -> list[tuple[str, Version]]:
+    """Resolve requirement and return all matching candidates.
+
+    Returns list of (url, version) tuples sorted by version (highest first).
+    """
+    # Get all matching candidates directly from provider
+    # instead of using resolvelib's resolver which picks just one
+    identifier = provider.identify(req)
     try:
-        result = rslvr.resolve([req])
+        candidates = provider.find_matches(
+            identifier=identifier,
+            requirements={identifier: [req]},
+            incompatibilities={},
+        )
     except resolvelib.resolvers.ResolverException as err:
         constraint = provider.constraints.get_constraint(req.name)
         provider_desc = provider.get_provider_description()
-        # Include the original error message to preserve detailed information
-        # (e.g., file types, pre-release info from PyPIProvider)
         original_msg = str(err)
         raise resolvelib.resolvers.ResolverException(
             f"Unable to resolve requirement specifier {req} with constraint {constraint} using {provider_desc}: {original_msg}"
         ) from err
-    # resolvelib actually just returns one candidate per requirement.
-    # result.mapping is map from an identifier to its resolved candidate
-    candidate: Candidate
-    for candidate in result.mapping.values():
-        return candidate.url, candidate.version
-    raise ValueError(f"Unable to resolve {req}")
+
+    # Convert candidates to list of (url, version) tuples
+    # Candidates are already sorted by version (highest first)
+    return [(candidate.url, candidate.version) for candidate in candidates]
 
 
 def get_project_from_pypi(
@@ -468,8 +478,8 @@ def validate_candidate(
         incompatibilities: CandidatesMap,
         candidate: Candidate,
     ) -> bool:
-        identifier_reqs = list(requirements[identifier])
-        bad_versions = {c.version for c in incompatibilities[identifier]}
+        identifier_reqs = list(requirements.get(identifier, []))
+        bad_versions = {c.version for c in incompatibilities.get(identifier, [])}
         # Skip versions that are known bad
         if candidate.version in bad_versions:
             if DEBUG_RESOLVER:
@@ -573,8 +583,11 @@ def _get_no_match_error_message(
 
         Subclasses should override this to provide provider-specific error details.
         """
-        r = next(iter(requirements[identifier]))
-        return f"found no match for {r} using {self.get_provider_description()}"
+        reqs = requirements.get(identifier, [])
+        if reqs:
+            r = next(iter(reqs))
+            return f"found no match for {r} using {self.get_provider_description()}"
+        return f"found no match for identifier {identifier} using {self.get_provider_description()}"
 
     def find_matches(
         self,