Merge branch 'main' into py314-docker

Author: zanieb

crates/uv-python/build.rs

@@ -1,5 +1,5 @@
-use std::fs;
-use std::path::Path;
+use std::path::PathBuf;
+use std::{env, fs};
 
 fn process_json(data: &serde_json::Value) -> serde_json::Value {
     let mut out_data = serde_json::Map::new();
@@ -14,9 +14,25 @@ fn process_json(data: &serde_json::Value) -> serde_json::Value {
 }
 
 fn main() {
-    let version_metadata = "download-metadata.json";
-    println!("cargo::rerun-if-changed={version_metadata}");
-    let target = Path::new("src/download-metadata-minified.json");
+    let version_metadata = PathBuf::from_iter([
+        env::var("CARGO_MANIFEST_DIR").unwrap(),
+        "download-metadata.json".into(),
+    ]);
+
+    let version_metadata_minified = PathBuf::from_iter([
+        env::var("OUT_DIR").unwrap(),
+        "download-metadata-minified.json".into(),
+    ]);
+
+    println!(
+        "cargo::rerun-if-changed={}",
+        version_metadata.to_str().unwrap()
+    );
+
+    println!(
+        "cargo::rerun-if-changed={}",
+        version_metadata_minified.to_str().unwrap()
+    );
 
     let json_data: serde_json::Value = serde_json::from_str(
         #[allow(clippy::disallowed_methods)]
@@ -28,7 +44,7 @@ fn main() {
 
     #[allow(clippy::disallowed_methods)]
     fs::write(
-        target,
+        version_metadata_minified,
         serde_json::to_string(&filtered_data).expect("Failed to serialize JSON"),
     )
     .expect("Failed to write minified JSON");

crates/uv-python/download-metadata.json

@@ -1668,9 +1668,19 @@ fn is_windows_store_shim(_path: &Path) -> bool {
 impl PythonVariant {
     fn matches_interpreter(self, interpreter: &Interpreter) -> bool {
         match self {
-            // TODO(zanieb): Right now, we allow debug interpreters to be selected by default for
-            // backwards compatibility, but we may want to change this in the future.
-            Self::Default => !interpreter.gil_disabled(),
+            Self::Default => {
+                // TODO(zanieb): Right now, we allow debug interpreters to be selected by default for
+                // backwards compatibility, but we may want to change this in the future.
+                if (interpreter.python_major(), interpreter.python_minor()) >= (3, 14) {
+                    // For Python 3.14+, the free-threaded build is not considered experimental
+                    // and can satisfy the default variant without opt-in
+                    true
+                } else {
+                    // In Python 3.13 and earlier, the free-threaded build is considered
+                    // experimental and requires explicit opt-in
+                    !interpreter.gil_disabled()
+                }
+            }
             Self::Debug => interpreter.debug_enabled(),
             Self::Freethreaded => interpreter.gil_disabled(),
             Self::FreethreadedDebug => interpreter.gil_disabled() && interpreter.debug_enabled(),
@@ -1935,6 +1945,24 @@ impl PythonRequest {
         }
     }
 
+    /// Check if this request includes a specific prerelease version.
+    pub fn includes_prerelease(&self) -> bool {
+        match self {
+            Self::Default => false,
+            Self::Any => false,
+            Self::Version(version_request) => version_request.prerelease().is_some(),
+            Self::Directory(..) => false,
+            Self::File(..) => false,
+            Self::ExecutableName(..) => false,
+            Self::Implementation(..) => false,
+            Self::ImplementationVersion(_, version) => version.prerelease().is_some(),
+            Self::Key(request) => request
+                .version
+                .as_ref()
+                .is_some_and(|request| request.prerelease().is_some()),
+        }
+    }
+
     /// Check if a given interpreter satisfies the interpreter request.
     pub fn satisfied(&self, interpreter: &Interpreter, cache: &Cache) -> bool {
         /// Returns `true` if the two paths refer to the same interpreter executable.
@@ -2555,6 +2583,17 @@ impl VersionRequest {
         }
     }
 
+    /// Return the pre-release segment of the request, if any.
+    pub(crate) fn prerelease(&self) -> Option<&Prerelease> {
+        match self {
+            Self::Any | Self::Default | Self::Range(_, _) => None,
+            Self::Major(_, _) => None,
+            Self::MajorMinor(_, _, _) => None,
+            Self::MajorMinorPatch(_, _, _, _) => None,
+            Self::MajorMinorPrerelease(_, _, prerelease, _) => Some(prerelease),
+        }
+    }
+
     /// Check if the request is for a version supported by uv.
     ///
     /// If not, an `Err` is returned with an explanatory message.
@@ -2760,8 +2799,8 @@ impl VersionRequest {
             ),
             Self::MajorMinorPrerelease(self_major, self_minor, self_prerelease, _) => {
                 // Pre-releases of Python versions are always for the zero patch version
-                (*self_major, *self_minor, 0) == (major, minor, patch)
-                    && prerelease.is_none_or(|pre| *self_prerelease == pre)
+                (*self_major, *self_minor, 0, Some(*self_prerelease))
+                    == (major, minor, patch, prerelease)
             }
         }
     }

crates/uv-python/src/discovery.rs

@@ -792,7 +792,8 @@ impl FromStr for PythonDownloadRequest {
     }
 }
 
-const BUILTIN_PYTHON_DOWNLOADS_JSON: &str = include_str!("download-metadata-minified.json");
+const BUILTIN_PYTHON_DOWNLOADS_JSON: &str =
+    include_str!(concat!(env!("OUT_DIR"), "/download-metadata-minified.json"));
 static PYTHON_DOWNLOADS: OnceCell<std::borrow::Cow<'static, [ManagedPythonDownload]>> =
     OnceCell::new();
 

crates/uv-python/src/downloads.rs

@@ -681,19 +681,22 @@ impl ManagedPythonInstallation {
         if (self.key.major, self.key.minor) != (other.key.major, other.key.minor) {
             return false;
         }
-        // Require a newer, or equal patch version (for pre-release upgrades)
-        if self.key.patch < other.key.patch {
-            return false;
+        // If the patch versions are the same, we're handling a pre-release upgrade
+        if self.key.patch == other.key.patch {
+            return match (self.key.prerelease, other.key.prerelease) {
+                // Require a newer pre-release, if present on both
+                (Some(self_pre), Some(other_pre)) => self_pre > other_pre,
+                // Allow upgrade from pre-release to stable
+                (None, Some(_)) => true,
+                // Do not upgrade from pre-release to stable, or for matching versions
+                (_, None) => false,
+            };
         }
-        if let Some(other_pre) = other.key.prerelease {
-            if let Some(self_pre) = self.key.prerelease {
-                return self_pre > other_pre;
-            }
-            // Do not upgrade from non-prerelease to prerelease
+        // Require a newer patch version
+        if self.key.patch < other.key.patch {
             return false;
         }
-        // Do not upgrade if the patch versions are the same
-        self.key.patch != other.key.patch
+        true
     }
 
     pub fn url(&self) -> Option<&str> {
@@ -1136,9 +1139,10 @@ mod tests {
             PythonVariant::Default,
         );
 
-        // Stable version should not upgrade from prerelease
-        assert!(!stable.is_upgrade_of(&prerelease));
-        // Prerelease should not upgrade to stable (same patch version)
+        // A stable version is an upgrade from prerelease
+        assert!(stable.is_upgrade_of(&prerelease));
+
+        // Prerelease are not upgrades of stable versions
         assert!(!prerelease.is_upgrade_of(&stable));
     }
 

crates/uv-python/src/managed.rs

@@ -2938,13 +2938,31 @@ impl ForkState {
                     resolution_strategy,
                     ResolutionStrategy::Lowest | ResolutionStrategy::LowestDirect(..)
                 );
+
                 if !has_url && missing_lower_bound && strategy_lowest {
-                    warn_user_once!(
-                        "The direct dependency `{name}` is unpinned. \
-                        Consider setting a lower bound when using `--resolution lowest` \
-                        or `--resolution lowest-direct` to avoid using outdated versions.",
-                        name = package.name_no_root().unwrap(),
-                    );
+                    let name = package.name_no_root().unwrap();
+                    // Handle cases where a package is listed both without and with a lower bound.
+                    // Example:
+                    // ```
+                    // "coverage[toml] ; python_version < '3.11'",
+                    // "coverage >= 7.10.0",
+                    // ```
+                    let bound_on_other_package = dependencies.iter().any(|other| {
+                        Some(name) == other.package.name()
+                            && !other
+                                .version
+                                .bounding_range()
+                                .map(|(lowest, _highest)| lowest == Bound::Unbounded)
+                                .unwrap_or(true)
+                    });
+
+                    if !bound_on_other_package {
+                        warn_user_once!(
+                            "The direct dependency `{name}` is unpinned. \
+                            Consider setting a lower bound when using `--resolution lowest` \
+                            or `--resolution lowest-direct` to avoid using outdated versions.",
+                        );
+                    }
                 }
             }
 

crates/uv-resolver/src/resolver/mod.rs

@@ -285,9 +285,9 @@ pub(crate) async fn install(
         .collect::<IndexSet<_>>();
 
     if upgrade
-        && requests
-            .iter()
-            .any(|request| request.request.includes_patch())
+        && requests.iter().any(|request| {
+            request.request.includes_patch() || request.request.includes_prerelease()
+        })
     {
         writeln!(
             printer.stderr(),
@@ -551,19 +551,28 @@ pub(crate) async fn install(
                 printer.stderr(),
                 "There are no installed versions to upgrade"
             )?;
-        } else if requests.len() > 1 {
+        } else if upgrade && is_unspecified_upgrade {
+            writeln!(
+                printer.stderr(),
+                "All versions already on latest supported patch release"
+            )?;
+        } else if let [request] = requests.as_slice() {
+            // Convert to the inner request
+            let request = &request.request;
             if upgrade {
-                if is_unspecified_upgrade {
-                    writeln!(
-                        printer.stderr(),
-                        "All versions already on latest supported patch release"
-                    )?;
-                } else {
-                    writeln!(
-                        printer.stderr(),
-                        "All requested versions already on latest supported patch release"
-                    )?;
-                }
+                writeln!(
+                    printer.stderr(),
+                    "{request} is already on the latest supported patch release"
+                )?;
+            } else {
+                writeln!(printer.stderr(), "{request} is already installed")?;
+            }
+        } else {
+            if upgrade {
+                writeln!(
+                    printer.stderr(),
+                    "All requested versions already on latest supported patch release"
+                )?;
             } else {
                 writeln!(printer.stderr(), "All requested versions already installed")?;
             }