Retry uv pip install with an inferred Python constraint

When `uv pip install` fails to resolve because the venv's Python is too old for a
(possibly transitive) dependency, parse the required Python version from uv's error,
recreate the venv with that constraint, and retry once. Closes #1618.

Author: nikosavola

crates/prek/src/languages/python/python.rs

@@ -7,9 +7,10 @@ use anyhow::{Context, Result};
 use mea::once::OnceMap;
 use prek_consts::env_vars::EnvVars;
 use prek_consts::prepend_paths;
+use regex::Regex;
 use rustc_hash::FxBuildHasher;
 use serde::Deserialize;
-use tracing::{debug, trace};
+use tracing::debug;
 
 use crate::cli::reporter::HookInstallReporter;
 use crate::cli::run::HookRunReporter;
@@ -119,32 +120,7 @@ impl LanguageBackend for Python {
             .context("Failed to create Python virtual environment")?;
 
         // Install dependencies
-        let mut pip_install = Self::pip_install_command(&uv, store, &info.env_path);
-
-        if let Some(repo_path) = hook.repo_path() {
-            trace!(
-                "Installing dependencies from repo path: {}",
-                repo_path.display()
-            );
-            pip_install
-                .arg("--directory")
-                .arg(repo_path)
-                .arg(".")
-                .args(&hook.additional_dependencies)
-                .output()
-                .await?;
-        } else if !hook.additional_dependencies.is_empty() {
-            trace!(
-                "Installing additional dependencies: {:?}",
-                hook.additional_dependencies
-            );
-            pip_install
-                .args(&hook.additional_dependencies)
-                .output()
-                .await?;
-        } else {
-            debug!("No dependencies to install");
-        }
+        Self::install_dependencies(&uv, store, &info, &hook, &hook.language_request).await?;
 
         let python = python_exec(&info.env_path);
         let python_info = query_python_info(&python)
@@ -238,6 +214,48 @@ fn to_uv_python_request(request: &LanguageRequest) -> Option<String> {
     }
 }
 
+/// The highest `requires Python >=X.Y` bound in a uv resolution failure, as a
+/// `major.minor` request (the bound is a minimum, so the patch is dropped).
+fn infer_python_request(stderr: &[u8]) -> Option<LanguageRequest> {
+    static PYTHON_BOUND: LazyLock<Regex> =
+        LazyLock::new(|| Regex::new(r"Python\s*>=?\s*(\d+\.\d+(?:\.\d+)?)").unwrap());
+
+    let stderr = String::from_utf8_lossy(stderr);
+    let (major, minor, _) = PYTHON_BOUND
+        .captures_iter(&stderr)
+        .filter_map(|caps| Some(version_sort_key(caps.get(1)?.as_str())))
+        .max()?;
+
+    Some(LanguageRequest::Python(PythonRequest::MajorMinor(
+        major, minor,
+    )))
+}
+
+/// Whether `original` allows the `inferred` interpreter. The inferred request is always a
+/// `major.minor` from a uv `Requires-Python` bound; the default (`Any`) permits anything.
+fn request_permits(original: &LanguageRequest, inferred: &LanguageRequest) -> bool {
+    let LanguageRequest::Python(PythonRequest::MajorMinor(major, minor)) = inferred else {
+        return false;
+    };
+    match original {
+        LanguageRequest::Any { .. } => true,
+        LanguageRequest::Python(request) => {
+            request.permits(&semver::Version::new(*major, *minor, 0))
+        }
+        _ => false,
+    }
+}
+
+/// Sort key for a `major.minor[.patch]` version string; unparsable parts sort as 0.
+fn version_sort_key(version: &str) -> (u64, u64, u64) {
+    let mut parts = version.split('.').map(|p| p.parse::<u64>().unwrap_or(0));
+    (
+        parts.next().unwrap_or(0),
+        parts.next().unwrap_or(0),
+        parts.next().unwrap_or(0),
+    )
+}
+
 #[derive(Debug, Clone, Copy)]
 enum VenvAttempt {
     PrekManaged,
@@ -267,6 +285,64 @@ impl Python {
         cmd
     }
 
+    /// Install the hook's dependencies, retrying once with a newer venv Python if `uv`
+    /// fails to resolve because the current one is too old for a (transitive)
+    /// dependency. On no inferable version, the original error is surfaced.
+    async fn install_dependencies(
+        uv: &Uv,
+        store: &Store,
+        info: &InstallInfo,
+        hook: &Hook,
+        python_request: &LanguageRequest,
+    ) -> Result<()> {
+        if hook.repo_path().is_none() && hook.additional_dependencies.is_empty() {
+            debug!("No dependencies to install");
+            return Ok(());
+        }
+
+        let build = || {
+            let mut cmd = Self::pip_install_command(uv, store, &info.env_path);
+            if let Some(repo_path) = hook.repo_path() {
+                cmd.arg("--directory").arg(repo_path).arg(".");
+            }
+            cmd.args(&hook.additional_dependencies);
+            cmd
+        };
+
+        // Capture the failure instead of bailing, so we can inspect and maybe retry.
+        let mut cmd = build();
+        let output = cmd.check(false).output().await?;
+        if output.status.success() {
+            return Ok(());
+        }
+
+        // Retry only with a different version the original request still permits (so we never
+        // install an interpreter the user ruled out), and never download for a `system` request.
+        let retry_request = infer_python_request(&output.stderr)
+            .filter(|request| request != python_request)
+            .filter(|_| python_request.allows_download())
+            .filter(|request| request_permits(python_request, request));
+
+        let Some(retry_request) = retry_request else {
+            cmd.check_output(output)?;
+            return Ok(());
+        };
+
+        // Preserve the original resolution error if the venv recreate fails.
+        let original_error = String::from_utf8_lossy(&output.stderr).into_owned();
+        debug!("uv pip install failed to resolve; retrying with a newer Python");
+        Self::create_venv(uv, store, info, &retry_request)
+            .await
+            .with_context(|| {
+                format!(
+                    "Failed to recreate the venv with the inferred Python version.\n\
+                     Original dependency resolution error:\n{original_error}"
+                )
+            })?;
+        build().check(true).output().await?;
+        Ok(())
+    }
+
     async fn create_venv(
         uv: &Uv,
         store: &Store,
@@ -543,4 +619,47 @@ mod tests {
         assert_eq!(envs.get(EnvVars::UV_SYSTEM_PYTHON), Some(&None));
         assert_eq!(envs.get(EnvVars::UV_PYTHON), Some(&None));
     }
+
+    #[test]
+    fn infer_python_request_picks_highest_bound() {
+        use super::{infer_python_request, to_uv_python_request};
+
+        // No Python bound in the error -> nothing to refine.
+        assert!(infer_python_request(b"error: something unrelated failed").is_none());
+
+        // A single bound.
+        let req = infer_python_request(b"Because foo requires Python >=3.10, ...").unwrap();
+        assert_eq!(to_uv_python_request(&req).as_deref(), Some("3.10"));
+
+        // Multiple bounds -> the highest wins (and beats lexical: 3.9 < 3.10). The
+        // patch is dropped since the bound is a minimum, so `>=3.11.2` -> `3.11`.
+        let req =
+            infer_python_request(b"requires Python >=3.9 and bar requires Python>=3.11.2 so ...")
+                .unwrap();
+        assert_eq!(to_uv_python_request(&req).as_deref(), Some("3.11"));
+    }
+
+    #[test]
+    fn request_permits_respects_explicit_requests() {
+        use super::request_permits;
+        use crate::languages::python::PythonRequest;
+
+        let inferred = LanguageRequest::Python(PythonRequest::MajorMinor(3, 11));
+
+        // The default request allows any inferred interpreter.
+        assert!(request_permits(
+            &LanguageRequest::Any { system_only: false },
+            &inferred
+        ));
+
+        // An open range that still covers the inferred version.
+        let range = LanguageRequest::Python(">=3.8".parse::<PythonRequest>().unwrap());
+        assert!(request_permits(&range, &inferred));
+
+        // Requests that rule the inferred version out are not retried.
+        let pinned = LanguageRequest::Python(PythonRequest::MajorMinor(3, 9));
+        assert!(!request_permits(&pinned, &inferred));
+        let capped = LanguageRequest::Python(">=3.8, <3.11".parse::<PythonRequest>().unwrap());
+        assert!(!request_permits(&capped, &inferred));
+    }
 }

crates/prek/src/languages/python/version.rs

@@ -76,7 +76,11 @@ impl PythonRequest {
     }
 
     pub(crate) fn satisfied_by(&self, install_info: &InstallInfo) -> bool {
-        let version = &install_info.language_version;
+        self.permits(&install_info.language_version)
+    }
+
+    /// Whether a concrete interpreter version is allowed by this request.
+    pub(crate) fn permits(&self, version: &semver::Version) -> bool {
         match self {
             PythonRequest::Any => true,
             PythonRequest::Major(major) => version.major == *major,