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 <noreply@anthropic.com>
Signed-off-by: Rohan Devasthale <rdevasth@redhat.com>

Author: rd4398

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
 
@@ -56,14 +56,14 @@ def __init__(
             tuple[str, bool], list[tuple[str, Version]]
         ] = {}
 
-    def resolve_all(
+    def resolve(
         self,
         req: Requirement,
         req_type: RequirementType,
         parent_req: Requirement | None = None,
         pre_built: bool | None = None,
-    ) -> list[tuple[str, Version]]:
-        """Resolve package requirement to all matching versions.
+    ) -> tuple[str, Version]:
+        """Resolve package requirement to the best matching version.
 
         Tries resolution strategies in order:
         1. Session cache (if previously resolved)
@@ -78,7 +78,7 @@ def resolve_all(
                 If None (default), uses package build info to determine.
 
         Returns:
-            List of (url, version) tuples sorted by version (highest first)
+            (url, version) tuple for the highest matching version
 
         Raises:
             ValueError: If req contains a git URL and pre_built is False
@@ -101,44 +101,13 @@ def resolve_all(
         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
         results = self._resolve(req, req_type, parent_req, pre_built)
 
         # Cache the result
         self.cache_resolution(req, pre_built, results)
-        return results
-
-    def resolve(
-        self,
-        req: Requirement,
-        req_type: RequirementType,
-        parent_req: Requirement | None = None,
-        pre_built: bool | None = None,
-    ) -> tuple[str, Version]:
-        """Resolve package requirement to the best matching version.
-
-        Tries resolution strategies in order:
-        1. Session cache (if previously resolved)
-        2. Previous dependency graph
-        3. PyPI resolution (source or prebuilt based on package build info)
-
-        Args:
-            req: Package requirement
-            req_type: Type of requirement
-            parent_req: Parent requirement from dependency chain
-            pre_built: Optional override to force prebuilt (True) or source (False).
-                If None (default), uses package build info to determine.
-
-        Returns:
-            (url, version) tuple for the highest matching version
-
-        Raises:
-            ValueError: If req contains a git URL and pre_built is False
-                (git URL source resolution must be handled by Bootstrapper)
-        """
-        results = self.resolve_all(req, req_type, parent_req, pre_built)
         return results[0]
 
     def _resolve(
@@ -177,25 +146,62 @@ def _resolve(
             )
             return cached_resolution
 
-        # Fallback to PyPI
-        result: list[tuple[str, Version]]
+        # Fallback to PyPI using provider pattern
+        pbi = self.ctx.package_build_info(req)
+
         if pre_built:
             # Resolve prebuilt wheel
-            servers = wheels.get_wheel_server_urls(
-                self.ctx, req, cache_wheel_server_url=resolver.PYPI_SERVER_URL
-            )
-            result = wheels.resolve_prebuilt_wheel_all(
-                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)
-            result = sources.resolve_source_all(
+            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 result
+            return resolver.resolve_from_provider(provider, req)
 
     def get_cached_resolution(
         self,

src/fromager/resolver.py

@@ -76,7 +76,7 @@ def match_py_req(py_req: str, *, python_version: Version = PYTHON_VERSION) -> bo
     return python_version in SpecifierSet(py_req)
 
 
-def resolve_all(
+def resolve(
     *,
     ctx: context.WorkContext,
     req: Requirement,
@@ -85,10 +85,10 @@ def resolve_all(
     include_wheels: bool = True,
     req_type: RequirementType | None = None,
     ignore_platform: bool = False,
-) -> list[tuple[str, Version]]:
-    """Resolve requirement and return all matching versions.
+) -> tuple[str, Version]:
+    """Resolve requirement and return the best matching version.
 
-    Returns list of (url, version) tuples sorted by version (highest first).
+    Returns (url, version) tuple for the highest matching version.
     """
     # Create the (reusable) resolver.
     provider = overrides.find_and_invoke(
@@ -103,32 +103,7 @@ def resolve_all(
         req_type=req_type,
         ignore_platform=ignore_platform,
     )
-    return resolve_from_provider(provider, req)
-
-
-def resolve(
-    *,
-    ctx: context.WorkContext,
-    req: Requirement,
-    sdist_server_url: str,
-    include_sdists: bool = True,
-    include_wheels: bool = True,
-    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.
-    """
-    results = resolve_all(
-        ctx=ctx,
-        req=req,
-        sdist_server_url=sdist_server_url,
-        include_sdists=include_sdists,
-        include_wheels=include_wheels,
-        req_type=req_type,
-        ignore_platform=ignore_platform,
-    )
+    results = resolve_from_provider(provider, req)
     return results[0]
 
 

src/fromager/sources.py

@@ -125,62 +125,47 @@ def download_source(
 
 
 @metrics.timeit(description="resolve source")
-def resolve_source_all(
+def resolve_source(
     *,
     ctx: context.WorkContext,
     req: Requirement,
     sdist_server_url: str,
     req_type: RequirementType | None = None,
-) -> list[tuple[str, Version]]:
-    """Return list of (URL, version) for all matching source versions.
-
-    Returns list sorted by version (highest first).
+) -> tuple[str, Version]:
+    """Return (URL, version) for the best matching source version.
 
-    Supports both old and new plugin interfaces:
-    - New plugins implement resolve_source_all() returning list
-    - Old plugins implement resolve_source() returning single tuple (backward compat)
+    Returns the highest matching version.
     """
     constraint = ctx.constraints.get_constraint(req.name)
     logger.debug(
         f"resolving requirement {req} using {sdist_server_url} with constraint {constraint}"
     )
 
     try:
-        # Check for new plugin hook first (returns list)
-        new_plugin = overrides.find_override_method(req.name, "resolve_source_all")
-        if new_plugin:
-            resolver_results = overrides.find_and_invoke(
-                req.name,
-                "resolve_source_all",
-                default_resolve_source_all,
-                ctx=ctx,
-                req=req,
-                sdist_server_url=sdist_server_url,
-                req_type=req_type,
-            )
-        else:
-            # Fall back to old plugin hook (returns single tuple for backward compat)
-            old_plugin = overrides.find_override_method(req.name, "resolve_source")
-            if old_plugin:
-                single_result = overrides.find_and_invoke(
-                    req.name,
-                    "resolve_source",
-                    default_resolve_source,
-                    ctx=ctx,
-                    req=req,
-                    sdist_server_url=sdist_server_url,
-                    req_type=req_type,
-                )
-                # Wrap old plugin result in list
-                resolver_results = [single_result]
-            else:
-                # No plugin, use default
-                resolver_results = default_resolve_source_all(
-                    ctx=ctx,
-                    req=req,
-                    sdist_server_url=sdist_server_url,
-                    req_type=req_type,
-                )
+        # Get provider via plugin hook or use default
+        pbi = ctx.package_build_info(req)
+        override_sdist_server_url = pbi.resolver_sdist_server_url(sdist_server_url)
+
+        provider = overrides.find_and_invoke(
+            req.name,
+            "get_resolver_provider",
+            resolver.default_resolver_provider,
+            ctx=ctx,
+            req=req,
+            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,
+        )
+
+        # Get all matching candidates from provider
+        results = resolver.resolve_from_provider(provider, req)
+
+        # Return highest version (first in sorted list)
+        url, version = results[0]
+        return str(url), version
+
     except (
         resolvelib.InconsistentCandidate,
         resolvelib.RequirementsConflicted,
@@ -189,78 +174,6 @@ def resolve_source_all(
         logger.debug(f"could not resolve {req} with {constraint}: {err}")
         raise
 
-    if not isinstance(resolver_results, list):
-        raise ValueError(
-            f"expected list of (url, version) tuples, got {type(resolver_results)}"
-        )
-
-    # Validate each tuple in the list
-    for _url, version in resolver_results:
-        if not isinstance(version, Version):
-            raise ValueError(f"expected Version, got {type(version)}: {version}")
-
-    return [(str(url), version) for url, version in resolver_results]
-
-
-def resolve_source(
-    *,
-    ctx: context.WorkContext,
-    req: Requirement,
-    sdist_server_url: str,
-    req_type: RequirementType | None = None,
-) -> tuple[str, Version]:
-    """Return (URL, version) for the best matching source version.
-
-    Returns the highest matching version.
-    """
-    results = resolve_source_all(
-        ctx=ctx,
-        req=req,
-        sdist_server_url=sdist_server_url,
-        req_type=req_type,
-    )
-    result: tuple[str, Version] = results[0]
-    return result
-
-
-def default_resolve_source_all(
-    ctx: context.WorkContext,
-    req: Requirement,
-    sdist_server_url: str,
-    req_type: RequirementType | None = None,
-) -> list[tuple[str, Version]]:
-    """Return list of (URL, version) for all matching source versions.
-
-    Returns list sorted by version (highest first).
-    """
-    pbi = ctx.package_build_info(req)
-    override_sdist_server_url = pbi.resolver_sdist_server_url(sdist_server_url)
-
-    return resolver.resolve_all(
-        ctx=ctx,
-        req=req,
-        sdist_server_url=override_sdist_server_url,
-        include_sdists=pbi.resolver_include_sdists,
-        include_wheels=pbi.resolver_include_wheels,
-        req_type=req_type,
-        ignore_platform=pbi.resolver_ignore_platform,
-    )
-
-
-def default_resolve_source(
-    ctx: context.WorkContext,
-    req: Requirement,
-    sdist_server_url: str,
-    req_type: RequirementType | None = None,
-) -> tuple[str, Version]:
-    """Return (URL, version) for the best matching source version.
-
-    Returns the highest matching version.
-    """
-    results = default_resolve_source_all(ctx, req, sdist_server_url, req_type)
-    result: tuple[str, Version] = results[0]
-    return result
-
 
 def default_download_source(
     ctx: context.WorkContext,