Allow incompatible requires-python for source distributions with static metadata

crates/uv-dispatch/src/lib.rs

@@ -132,6 +132,10 @@ impl<'a> BuildDispatch<'a> {
 impl<'a> BuildContext for BuildDispatch<'a> {
     type SourceDistBuilder = SourceBuild;
 
+    fn interpreter(&self) -> &Interpreter {
+        self.interpreter
+    }
+
     fn cache(&self) -> &Cache {
         self.cache
     }

crates/uv-distribution-types/src/buildable.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 use url::Url;
 use uv_distribution_filename::SourceDistExtension;
 use uv_git::GitUrl;
-use uv_pep440::Version;
+use uv_pep440::{Version, VersionSpecifiers};
 use uv_pep508::VerbatimUrl;
 
 use uv_normalize::PackageName;
@@ -64,6 +64,14 @@ impl BuildableSource<'_> {
             Self::Url(url) => matches!(url, SourceUrl::Directory(_)),
         }
     }
+
+    /// Return the Python version specifier required by the source, if available.
+    pub fn requires_python(&self) -> Option<&VersionSpecifiers> {
+        let Self::Dist(SourceDist::Registry(dist)) = self else {
+            return None;
+        };
+        dist.file.requires_python.as_ref()
+    }
 }
 
 impl std::fmt::Display for BuildableSource<'_> {

crates/uv-distribution/src/error.rs

@@ -10,7 +10,7 @@ use uv_client::WrappedReqwestError;
 use uv_distribution_filename::WheelFilenameError;
 use uv_fs::Simplified;
 use uv_normalize::PackageName;
-use uv_pep440::Version;
+use uv_pep440::{Version, VersionSpecifiers};
 use uv_pypi_types::{HashDigest, ParsedUrlError};
 
 #[derive(Debug, thiserror::Error)]
@@ -96,6 +96,8 @@ pub enum Error {
     NotFound(Url),
     #[error("Attempted to re-extract the source distribution for `{0}`, but the hashes didn't match. Run `{}` to clear the cache.", "uv cache clean".green())]
     CacheHeal(String),
+    #[error("The source distribution requires Python {0}, but {1} is installed")]
+    RequiresPython(VersionSpecifiers, Version),
 
     /// A generic request middleware error happened while making a request.
     /// Refer to the error message for more details.

crates/uv-distribution/src/source/mod.rs

@@ -1,10 +1,18 @@
 //! Fetch and build source distributions from remote sources.
 
 use std::borrow::Cow;
+use std::ops::Bound;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
 
+use crate::distribution_database::ManagedClient;
+use crate::error::Error;
+use crate::metadata::{ArchiveMetadata, GitWorkspaceMember, Metadata};
+use crate::reporter::Facade;
+use crate::source::built_wheel_metadata::BuiltWheelMetadata;
+use crate::source::revision::Revision;
+use crate::{Reporter, RequiresDist};
 use fs_err::tokio as fs;
 use futures::{FutureExt, TryStreamExt};
 use reqwest::Response;
@@ -26,19 +34,12 @@ use uv_distribution_types::{
 use uv_extract::hash::Hasher;
 use uv_fs::{rename_with_retry, write_atomic, LockedFile};
 use uv_metadata::read_archive_metadata;
+use uv_pep440::release_specifiers_to_ranges;
 use uv_platform_tags::Tags;
 use uv_pypi_types::{HashDigest, Metadata12, RequiresTxt, ResolutionMetadata};
 use uv_types::{BuildContext, SourceBuildTrait};
 use zip::ZipArchive;
 
-use crate::distribution_database::ManagedClient;
-use crate::error::Error;
-use crate::metadata::{ArchiveMetadata, GitWorkspaceMember, Metadata};
-use crate::reporter::Facade;
-use crate::source::built_wheel_metadata::BuiltWheelMetadata;
-use crate::source::revision::Revision;
-use crate::{Reporter, RequiresDist};
-
 mod built_wheel_metadata;
 mod revision;
 
@@ -1798,6 +1799,27 @@ impl<'a, T: BuildContext> SourceDistributionBuilder<'a, T> {
     ) -> Result<Option<ResolutionMetadata>, Error> {
         debug!("Preparing metadata for: {source}");
 
+        // Ensure that the _installed_ Python version is compatible with the `requires-python`
+        // specifier.
+        if let Some(requires_python) = source.requires_python() {
+            let installed = self.build_context.interpreter().python_version();
+            let target = release_specifiers_to_ranges(requires_python.clone())
+                .bounding_range()
+                .map(|bounding_range| bounding_range.0.cloned())
+                .unwrap_or(Bound::Unbounded);
+            let is_compatible = match target {
+                Bound::Included(target) => *installed >= target,
+                Bound::Excluded(target) => *installed > target,
+                Bound::Unbounded => true,
+            };
+            if !is_compatible {
+                return Err(Error::RequiresPython(
+                    requires_python.clone(),
+                    installed.clone(),
+                ));
+            }
+        }
+
         // Set up the builder.
         let mut builder = self
             .build_context

crates/uv-resolver/src/pubgrub/report.rs

@@ -11,7 +11,7 @@ use rustc_hash::FxHashMap;
 use uv_configuration::IndexStrategy;
 use uv_distribution_types::{Index, IndexCapabilities, IndexLocations, IndexUrl};
 use uv_normalize::PackageName;
-use uv_pep440::Version;
+use uv_pep440::{Version, VersionSpecifiers};
 
 use crate::candidate_selector::CandidateSelector;
 use crate::error::ErrorTree;
@@ -699,6 +699,14 @@ impl PubGrubReportFormatter<'_> {
                                 reason: reason.clone(),
                             });
                         }
+                        IncompletePackage::RequiresPython(requires_python, python_version) => {
+                            hints.insert(PubGrubHint::IncompatibleBuildRequirement {
+                                package: package.clone(),
+                                version: version.clone(),
+                                requires_python: requires_python.clone(),
+                                python_version: python_version.clone(),
+                            });
+                        }
                     }
                     break;
                 }
@@ -862,6 +870,17 @@ pub(crate) enum PubGrubHint {
         // excluded from `PartialEq` and `Hash`
         reason: String,
     },
+    /// The source distribution has a `requires-python` requirement that is not met by the installed
+    /// Python version (and static metadata is not available).
+    IncompatibleBuildRequirement {
+        package: PubGrubPackage,
+        // excluded from `PartialEq` and `Hash`
+        version: Version,
+        // excluded from `PartialEq` and `Hash`
+        requires_python: VersionSpecifiers,
+        // excluded from `PartialEq` and `Hash`
+        python_version: Version,
+    },
     /// The `Requires-Python` requirement was not satisfied.
     RequiresPython {
         source: PythonRequirementSource,
@@ -932,6 +951,9 @@ enum PubGrubHintCore {
     InvalidVersionStructure {
         package: PubGrubPackage,
     },
+    IncompatibleBuildRequirement {
+        package: PubGrubPackage,
+    },
     RequiresPython {
         source: PythonRequirementSource,
         requires_python: RequiresPython,
@@ -985,6 +1007,9 @@ impl From<PubGrubHint> for PubGrubHintCore {
             PubGrubHint::InvalidVersionStructure { package, .. } => {
                 Self::InvalidVersionStructure { package }
             }
+            PubGrubHint::IncompatibleBuildRequirement { package, .. } => {
+                Self::IncompatibleBuildRequirement { package }
+            }
             PubGrubHint::RequiresPython {
                 source,
                 requires_python,
@@ -1187,6 +1212,23 @@ impl std::fmt::Display for PubGrubHint {
                     package_requires_python.bold(),
                 )
             }
+            Self::IncompatibleBuildRequirement {
+                package,
+                version,
+                requires_python,
+                python_version,
+            } => {
+                write!(
+                    f,
+                    "{}{} The source distribution for {}=={} does not include static metadata. Generating metadata for this package requires Python {}, but Python {} is installed.",
+                    "hint".bold().cyan(),
+                    ":".bold(),
+                    package.bold(),
+                    version.bold(),
+                    requires_python.bold(),
+                    python_version.bold(),
+                )
+            }
             Self::RequiresPython {
                 source: PythonRequirementSource::Interpreter,
                 requires_python: _,

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

@@ -1,7 +1,7 @@
 use std::fmt::{Display, Formatter};
 
 use uv_distribution_types::IncompatibleDist;
-use uv_pep440::Version;
+use uv_pep440::{Version, VersionSpecifiers};
 
 /// The reason why a package or a version cannot be used.
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -40,6 +40,9 @@ pub(crate) enum UnavailableVersion {
     InvalidStructure,
     /// The wheel metadata was not found in the cache and the network is not available.
     Offline,
+    /// The source distribution has a `requires-python` requirement that is not met by the installed
+    /// Python version (and static metadata is not available).
+    RequiresPython(VersionSpecifiers),
 }
 
 impl UnavailableVersion {
@@ -51,6 +54,9 @@ impl UnavailableVersion {
             UnavailableVersion::InconsistentMetadata => "inconsistent metadata".into(),
             UnavailableVersion::InvalidStructure => "an invalid package format".into(),
             UnavailableVersion::Offline => "to be downloaded from a registry".into(),
+            UnavailableVersion::RequiresPython(requires_python) => {
+                format!("Python {requires_python}")
+            }
         }
     }
 
@@ -62,6 +68,7 @@ impl UnavailableVersion {
             UnavailableVersion::InconsistentMetadata => format!("has {self}"),
             UnavailableVersion::InvalidStructure => format!("has {self}"),
             UnavailableVersion::Offline => format!("needs {self}"),
+            UnavailableVersion::RequiresPython(..) => format!("requires {self}"),
         }
     }
 
@@ -73,6 +80,7 @@ impl UnavailableVersion {
             UnavailableVersion::InconsistentMetadata => format!("have {self}"),
             UnavailableVersion::InvalidStructure => format!("have {self}"),
             UnavailableVersion::Offline => format!("need {self}"),
+            UnavailableVersion::RequiresPython(..) => format!("require {self}"),
         }
     }
 }
@@ -143,6 +151,9 @@ pub(crate) enum IncompletePackage {
     InconsistentMetadata(String),
     /// The wheel has an invalid structure.
     InvalidStructure(String),
+    /// The source distribution has a `requires-python` requirement that is not met by the installed
+    /// Python version (and static metadata is not available).
+    RequiresPython(VersionSpecifiers, Version),
 }
 
 #[derive(Debug, Clone)]