Avoid building packages with dynamic versions

crates/pypi-types/src/metadata.rs

@@ -327,6 +327,73 @@ fn parse_version(metadata_version: &str) -> Result<(u8, u8), MetadataError> {
     Ok((major, minor))
 }
 
+/// Python Package Metadata 2.3 as specified in
+/// <https://packaging.python.org/specifications/core-metadata/>.
+///
+/// This is a subset of [`Metadata23`]; specifically, it omits the `version` and `requires-python`
+/// fields, which aren't necessary when extracting the requirements of a package without installing
+/// the package itself.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "kebab-case")]
+pub struct RequiresDist {
+    pub name: PackageName,
+    pub requires_dist: Vec<Requirement<VerbatimParsedUrl>>,
+    pub provides_extras: Vec<ExtraName>,
+}
+
+impl RequiresDist {
+    /// Extract the [`RequiresDist`] from a `pyproject.toml` file, as specified in PEP 621.
+    pub fn parse_pyproject_toml(contents: &str) -> Result<Self, MetadataError> {
+        let pyproject_toml: PyProjectToml = toml::from_str(contents)?;
+
+        let project = pyproject_toml
+            .project
+            .ok_or(MetadataError::FieldNotFound("project"))?;
+
+        // If any of the fields we need were declared as dynamic, we can't use the `pyproject.toml`
+        // file.
+        let dynamic = project.dynamic.unwrap_or_default();
+        for field in dynamic {
+            match field.as_str() {
+                "dependencies" => return Err(MetadataError::DynamicField("dependencies")),
+                "optional-dependencies" => {
+                    return Err(MetadataError::DynamicField("optional-dependencies"))
+                }
+                _ => (),
+            }
+        }
+
+        let name = project.name;
+
+        // Extract the requirements.
+        let mut requires_dist = project
+            .dependencies
+            .unwrap_or_default()
+            .into_iter()
+            .map(Requirement::from)
+            .collect::<Vec<_>>();
+
+        // Extract the optional dependencies.
+        let mut provides_extras: Vec<ExtraName> = Vec::new();
+        for (extra, requirements) in project.optional_dependencies.unwrap_or_default() {
+            requires_dist.extend(
+                requirements
+                    .into_iter()
+                    .map(Requirement::from)
+                    .map(|requirement| requirement.with_extra_marker(&extra))
+                    .collect::<Vec<_>>(),
+            );
+            provides_extras.push(extra);
+        }
+
+        Ok(Self {
+            name,
+            requires_dist,
+            provides_extras,
+        })
+    }
+}
+
 /// The headers of a distribution metadata file.
 #[derive(Debug)]
 struct Headers<'a>(Vec<mailparse::MailHeader<'a>>);

crates/uv-distribution/src/distribution_database.rs

@@ -34,7 +34,7 @@ use crate::archive::Archive;
 use crate::locks::Locks;
 use crate::metadata::{ArchiveMetadata, Metadata};
 use crate::source::SourceDistributionBuilder;
-use crate::{Error, LocalWheel, Reporter};
+use crate::{Error, LocalWheel, Reporter, RequiresDist};
 
 /// A cached high-level interface to convert distributions (a requirement resolved to a location)
 /// to a wheel or wheel metadata.
@@ -434,6 +434,11 @@ impl<'a, Context: BuildContext> DistributionDatabase<'a, Context> {
         Ok(metadata)
     }
 
+    /// Return the [`RequiresDist`] from a `pyproject.toml`, if it can be statically extracted.
+    pub async fn requires_dist(&self, project_root: &Path) -> Result<RequiresDist, Error> {
+        self.builder.requires_dist(project_root).await
+    }
+
     /// Stream a wheel from a URL, unzipping it into the cache as it's downloaded.
     async fn stream_wheel(
         &self,

crates/uv-distribution/src/lib.rs

@@ -2,7 +2,7 @@ pub use distribution_database::{DistributionDatabase, HttpArchivePointer, LocalA
 pub use download::LocalWheel;
 pub use error::Error;
 pub use index::{BuiltWheelIndex, RegistryWheelIndex};
-pub use metadata::{ArchiveMetadata, Metadata};
+pub use metadata::{ArchiveMetadata, Metadata, RequiresDist};
 pub use reporter::Reporter;
 pub use workspace::{ProjectWorkspace, Workspace, WorkspaceError, WorkspaceMember};