diff --git a/crates/uv-lock/src/lock/mod.rs b/crates/uv-lock/src/lock/mod.rs index 676bd31eb9a..93cc92c22f4 100644 --- a/crates/uv-lock/src/lock/mod.rs +++ b/crates/uv-lock/src/lock/mod.rs @@ -63,7 +63,7 @@ use uv_pypi_types::{ }; use uv_redacted::{DisplaySafeUrl, DisplaySafeUrlError}; use uv_resolver_types::{ - AnnotatedDist, ConflictMarker, DistributionMetadataIndex, MetadataResponse, + AnnotatedDist, ConflictMarker, DistributionMetadataIndex, MetadataResponse, PackageRole, ResolutionGraphNode, ResolverOutput, UniversalMarker, }; use uv_small_str::SmallString; @@ -2534,9 +2534,9 @@ impl Lock { // Git declarations can introduce direct sources needed by offline freshness checks. if metadata_free && matches!(package.id.source, Source::Git(..)) - && let Some(metadata) = dist.metadata.as_ref() + && let Some(metadata) = dist.metadata() { - package.metadata = PackageMetadata::from_distribution(metadata, root)?; + package.metadata = PackageMetadata::from_distribution(metadata, root, dist.role)?; } let mut wheel_marker = dist.marker; if let Some(supported_environments_marker) = supported_environments_marker { @@ -6655,13 +6655,8 @@ impl Package { let metadata = if id.source.is_immutable() { PackageMetadata::default() } else { - PackageMetadata::from_distribution( - annotated_dist - .metadata - .as_ref() - .expect("metadata is present"), - root, - )? + let metadata = annotated_dist.metadata().expect("metadata is present"); + PackageMetadata::from_distribution(metadata, root, annotated_dist.role)? }; Ok(Self { id, @@ -7450,13 +7445,30 @@ struct PackageMetadata { } impl PackageMetadata { - fn from_distribution(metadata: &DistributionMetadata, root: &Path) -> Result { + fn from_distribution( + metadata: &DistributionMetadata, + root: &Path, + package_role: PackageRole, + ) -> Result { let normalize = uv_preview::is_enabled(PreviewFeature::LockfileNormalization); + // We normally write dependency paths relative to the lockfile. For the current project and + // workspace members, preserve the user's choice of relative or absolute paths instead. + // Metadata from `tool.uv.dependency-metadata` already preserves that choice. + // Apply the path policy to the cloned requirements so shared metadata remains unchanged. + let relative_requirement = |requirement: &Requirement| { + let mut requirement = requirement.clone(); + match package_role { + PackageRole::Project | PackageRole::WorkspaceMember => { + requirement.set_force_relative(false); + } + PackageRole::Dependency => {} + } + requirement.relative_to(root) + }; let requires_dist = metadata .requires_dist .iter() - .cloned() - .map(|requirement| requirement.relative_to(root)) + .map(&relative_requirement) .collect::, _>>() .map(|requirements| { normalize_collection::<_, NormalizedRequirements>(requirements, normalize) @@ -7468,8 +7480,7 @@ impl PackageMetadata { .map(|(group, requirements)| { let requirements = requirements .iter() - .cloned() - .map(|requirement| requirement.relative_to(root)) + .map(&relative_requirement) .collect::, _>>() .map(|requirements| { normalize_collection::<_, NormalizedRequirements>(requirements, normalize) @@ -7592,8 +7603,7 @@ impl PackageId { // Omit versions for dynamic source trees. let version = if source.is_source_tree() && annotated_dist - .metadata - .as_ref() + .metadata() .is_some_and(|metadata| metadata.dynamic) { None diff --git a/crates/uv-resolver-types/src/distribution.rs b/crates/uv-resolver-types/src/distribution.rs index 8de0ef24df8..64b4afc4011 100644 --- a/crates/uv-resolver-types/src/distribution.rs +++ b/crates/uv-resolver-types/src/distribution.rs @@ -1,4 +1,5 @@ use std::fmt::Display; +use std::sync::Arc; use uv_distribution::Metadata; use uv_distribution_types::{ @@ -9,7 +10,7 @@ use uv_normalize::{ExtraName, GroupName, PackageName}; use uv_pep440::Version; use uv_pypi_types::HashDigests; -use crate::UniversalMarker; +use crate::{MetadataResponse, UniversalMarker}; /// The part of a package represented by a resolver graph node. #[derive(Debug, Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)] @@ -43,9 +44,20 @@ impl PackageNodeKind { } } +/// The role of a package relative to the resolver manifest. +#[derive(Debug, Clone, Copy)] +pub enum PackageRole { + /// The project named in the resolver manifest. + Project, + /// A workspace member other than the manifest's project. + WorkspaceMember, + /// A dependency that is neither the manifest's project nor a workspace member. + Dependency, +} + /// A pinned package with its resolved distribution and metadata. The [`ResolvedDist`] refers to a -/// specific distribution (e.g., a specific wheel), while the [`Metadata23`] refers to the metadata -/// for the package-version pair. +/// specific distribution (e.g., a specific wheel), while the [`Metadata`] describes +/// the package-version pair. #[derive(Debug, Clone)] pub struct AnnotatedDist { pub dist: ResolvedDist, @@ -53,7 +65,9 @@ pub struct AnnotatedDist { pub version: Version, pub kind: PackageNodeKind, pub hashes: HashDigests, - pub metadata: Option, + pub metadata: Option>, + /// The role of this package relative to the resolver manifest. + pub role: PackageRole, /// The "full" marker for this distribution. It precisely describes all /// marker environments for which this distribution _can_ be installed. /// That is, when doing a traversal over all of the distributions in a @@ -63,6 +77,17 @@ pub struct AnnotatedDist { } impl AnnotatedDist { + /// Returns the resolved metadata for this distribution, if available. + pub fn metadata(&self) -> Option<&Metadata> { + self.metadata.as_deref().and_then(|response| { + if let MetadataResponse::Found(archive) = response { + Some(&archive.metadata) + } else { + None + } + }) + } + /// Returns `true` if the [`AnnotatedDist`] is a base package (i.e., not an extra or a /// dependency group). pub(crate) fn is_base(&self) -> bool { diff --git a/crates/uv-resolver-types/src/lib.rs b/crates/uv-resolver-types/src/lib.rs index 2c3ef52af0d..0abd155d3d3 100644 --- a/crates/uv-resolver-types/src/lib.rs +++ b/crates/uv-resolver-types/src/lib.rs @@ -7,7 +7,7 @@ mod options; mod output; pub mod universal_marker; -pub use distribution::{AnnotatedDist, PackageNodeKind}; +pub use distribution::{AnnotatedDist, PackageNodeKind, PackageRole}; pub use metadata::{DistributionMetadataIndex, MetadataResponse, MetadataUnavailable}; pub use options::{Flexibility, Options, OptionsBuilder}; pub use output::{ConflictingDistributionError, ResolutionGraphNode, ResolverOutput}; diff --git a/crates/uv-resolver-types/src/output.rs b/crates/uv-resolver-types/src/output.rs index d00bc907ee8..1ffe0224280 100644 --- a/crates/uv-resolver-types/src/output.rs +++ b/crates/uv-resolver-types/src/output.rs @@ -42,7 +42,6 @@ pub struct ResolverOutput { } #[derive(Debug, Clone)] -#[expect(clippy::large_enum_variant)] pub enum ResolutionGraphNode { Root, Dist(AnnotatedDist), diff --git a/crates/uv-resolver/src/resolution/output.rs b/crates/uv-resolver/src/resolution/output.rs index 8c53681f408..d93f9234fbe 100644 --- a/crates/uv-resolver/src/resolution/output.rs +++ b/crates/uv-resolver/src/resolution/output.rs @@ -15,6 +15,7 @@ use uv_distribution_types::{ use uv_normalize::PackageName; use uv_pep440::{Version, VersionSpecifier}; use uv_pypi_types::{Conflicts, HashDigests, ParsedUrl, VerbatimParsedUrl, Yanked}; +use uv_resolver_types::PackageRole; use uv_types::HashStrategy; use crate::graph_ops::{marker_reachability, simplify_conflict_markers}; @@ -65,6 +66,13 @@ pub(crate) fn from_state( continue; }; let package = &entry.key().package; + let package_role = if project == Some(&package.name) { + PackageRole::Project + } else if workspace_members.contains(&package.name) { + PackageRole::WorkspaceMember + } else { + PackageRole::Dependency + }; let node = add_version( &mut graph, &mut diagnostics, @@ -73,7 +81,7 @@ pub(crate) fn from_state( index, package, selected, - project == Some(&package.name) || workspace_members.contains(&package.name), + package_role, ); entry.insert(node); } @@ -225,7 +233,7 @@ fn add_version( in_memory: &InMemoryIndex, package: &ResolutionPackage, selected: SelectedDistribution, - is_workspace_member: bool, + package_role: PackageRole, ) -> NodeIndex { let ResolutionPackage { name, @@ -258,17 +266,10 @@ fn add_version( }), } - // We normally write dependency paths relative to the lockfile. For the current project and - // workspace members, preserve the user's choice of relative or absolute paths instead. - // Metadata from `tool.uv.dependency-metadata` already preserves that choice. - // Only change this copy, not shared metadata. - let metadata = if is_workspace_member { - metadata.map(|metadata| metadata.with_force_relative(false)) - } else { - metadata - }; - - if let Some(metadata) = metadata.as_ref() { + if let Some(response) = metadata.as_ref() + && let MetadataResponse::Found(archive) = response.as_ref() + { + let metadata = &archive.metadata; // Validate the extra. if let Some(extra) = kind.extra() { if !metadata.provides_extra.contains(extra) { @@ -298,6 +299,7 @@ fn add_version( kind: kind.clone(), hashes, metadata, + role: package_role, marker: UniversalMarker::TRUE, })) } @@ -452,7 +454,7 @@ fn has_lower_bound( return true; } - let Some(metadata) = neighbor_dist.metadata.as_ref() else { + let Some(metadata) = neighbor_dist.metadata() else { // We can't check for lower bounds if we lack metadata. return true; }; diff --git a/crates/uv-resolver/src/resolver/resolution.rs b/crates/uv-resolver/src/resolver/resolution.rs index 46575dfc8ef..9e227420998 100644 --- a/crates/uv-resolver/src/resolver/resolution.rs +++ b/crates/uv-resolver/src/resolver/resolution.rs @@ -4,7 +4,6 @@ use std::sync::Arc; use rustc_hash::FxHashMap; use tracing::{Level, trace}; -use uv_distribution::Metadata; use uv_distribution_types::{Dist, DistributionId, Identifier, IndexUrl, ResolvedDist}; use uv_git::GitResolver; use uv_normalize::PackageName; @@ -51,13 +50,13 @@ enum SelectedSource { Url { dist: ResolvedDist, metadata_id: DistributionId, - metadata: Metadata, + metadata: Arc, }, Registry { dist: ResolvedDist, metadata_id: DistributionId, /// Direct-only resolution need not fetch registry metadata. - metadata: Option, + metadata: Option>, }, } @@ -74,7 +73,7 @@ impl SelectedDistribution { let response = index.distributions().get(&metadata_id).ok_or_else(|| { ResolveError::UnregisteredTask(format!("{} @ {}", package.name, url.verbatim)) })?; - let MetadataResponse::Found(archive) = &*response else { + let MetadataResponse::Found(_) = response.as_ref() else { return Err(ResolveError::PackageUnavailable(package.name.clone())); }; SelectedSource::Url { @@ -86,20 +85,20 @@ impl SelectedDistribution { version: Some(version.clone()), }, metadata_id, - metadata: archive.metadata.clone(), + metadata: response, } } else { let (dist, metadata_id) = pins.dist_and_id(&package.name, &version).ok_or_else(|| { ResolveError::UnregisteredTask(format!("{}=={version}", package.name)) })?; - let metadata = index.distributions().get(metadata_id).and_then(|response| { - if let MetadataResponse::Found(archive) = &*response { - Some(archive.metadata.clone()) - } else { - None - } - }); + let metadata = + index.distributions().get(metadata_id).and_then(|response| { + match response.as_ref() { + MetadataResponse::Found(_) => Some(response), + MetadataResponse::Unavailable(_) | MetadataResponse::Error(..) => None, + } + }); SelectedSource::Registry { dist: dist.clone(), metadata_id: metadata_id.clone(), @@ -114,7 +113,7 @@ impl SelectedDistribution { } /// Move the selected artifact and metadata into the output graph. - pub(crate) fn into_parts(self) -> (Version, ResolvedDist, Option) { + pub(crate) fn into_parts(self) -> (Version, ResolvedDist, Option>) { match self.source { SelectedSource::Url { dist, metadata, .. } => (self.version, dist, Some(metadata)), SelectedSource::Registry { dist, metadata, .. } => (self.version, dist, metadata),