feat: eliminate redundant host-side solver run for Docker builds (#1081)

## Summary
- When building with Docker, `get_package_paths()` triggers a full
finalized conda solver run on the host via `api.render(finalize=True)`.
This is redundant because Docker's `conda-build` re-solves from scratch
anyway.
- Adds a `finalize` parameter to `get_package_paths()` and skips the
expensive finalized render when a `docker_builder` is present
- Non-finalized metas use `bypass_env_check=True`, which avoids costly
dependency resolution. As documented in `utils.py:479-480`, this does
not change the package build string.
- Adds `--no-fast-resolve` CLI flag for debugging/opt-out

## Savings
10-60s per recipe by eliminating a redundant solver invocation. For R
packages, a single solve can take 10+ minutes.

## Risks
- **Medium**: Non-finalized metas may produce slightly different build
strings if `pin_compatible` or `run_exports` affect the hash. This could
cause:
- False "not in channel" -> rebuilds something that exists (wasteful but
not incorrect)
- False "in channel" -> skips a needed build (lower risk since
`check_recipe_skippable()` already does a fast check)
- **Mitigation**: Debug logging when fast path is used;
`--no-fast-resolve` opt-out flag
- Only changes behavior when `docker_builder is not None`

## Test plan
- [x] Run existing test suite: `pytest test/`
- [x] Integration test with Docker: `bioconda-utils build recipes/
config.yml --docker` on pyfaidx
- [x] Compare build results with and without `--no-fast-resolve`
- [x] Verify built packages are identical

Author: nh13

bioconda_utils/build.py

@@ -366,6 +366,7 @@ def build_recipes(
     live_logs: bool = True,
     exclude: List[str] = None,
     subdag_depth: int = None,
+    fast_resolve: bool = True,
 ):
     """
     Build one or many bioconda packages.
@@ -482,7 +483,17 @@ def build_recipes(
 
         logger.info("Determining expected packages for %s", recipe)
         try:
-            pkg_paths = utils.get_package_paths(recipe, check_channels, force=force)
+            # When building with Docker, skip the expensive finalized render
+            # on the host since Docker's conda-build will re-solve anyway.
+            # Non-finalized metas use bypass_env_check which avoids costly
+            # dependency resolution. The --no-fast-resolve flag can override this.
+            finalize = (docker_builder is None) if fast_resolve else True
+            pkg_paths = utils.get_package_paths(
+                recipe,
+                check_channels,
+                force=force,
+                finalize=finalize,
+            )
         except utils.DivergentBuildsError as exc:
             logger.error(
                 "BUILD ERROR: packages with divergent build strings in repository "

bioconda_utils/cli.py

@@ -619,6 +619,12 @@ def do_lint(
     action="store_true",
     help="Disable live logging during the build process",
 )
+@arg(
+    "--no-fast-resolve",
+    action="store_true",
+    help="Disable fast resolve: always run the full finalized conda solver on the host, "
+    "even when building with Docker. Useful for debugging build string mismatches.",
+)
 @arg("--exclude", nargs="+", help="Packages to exclude during this run")
 @arg(
     "--subdag-depth",
@@ -652,6 +658,7 @@ def build(
     record_build_failures=False,
     skiplist_leafs=False,
     disable_live_logs=False,
+    no_fast_resolve=False,
     exclude=None,
     subdag_depth=None,
 ):
@@ -726,6 +733,7 @@ def build(
         live_logs=(not disable_live_logs),
         exclude=exclude,
         subdag_depth=subdag_depth,
+        fast_resolve=not no_fast_resolve,
     )
     exit(0 if success else 1)
 

bioconda_utils/utils.py

@@ -1184,12 +1184,14 @@ def _filter_existing_packages(metas, check_channels):
     return new_metas, existing_metas, divergent_builds
 
 
-def get_package_paths(recipe, check_channels, force=False):
+def get_package_paths(recipe, check_channels, force=False, finalize=True):
     if not force:
         if check_recipe_skippable(recipe, check_channels):
             # NB: If we skip early here, we don't detect possible divergent builds.
             return []
-    platform, metas = _load_platform_metas(recipe, finalize=True)
+    if not finalize:
+        logger.debug("Using non-finalized render for %s (fast resolve)", recipe)
+    platform, metas = _load_platform_metas(recipe, finalize=finalize)
 
     # The recipe likely defined skip: True
     if not metas: