From ece26b673be316547919736d5dd632963f64c260 Mon Sep 17 00:00:00 2001 From: konstin Date: Tue, 29 Oct 2024 17:49:53 +0100 Subject: [PATCH] Merge uv-pubgrub into uv-pep440 Enabled by #8667 and https://github.com/pubgrub-rs/pubgrub/pull/262, we can remove the uv-pubgrub crate and move the conversion between pep440 specifiers and version ranges directly into pep440. In a next step, we can remove the `VersionRangesSpecifier` intermediary and perform the conversion directly. --- Cargo.lock | 14 +--- Cargo.toml | 3 +- crates/uv-build-backend/Cargo.toml | 1 - crates/uv-build-backend/src/metadata.rs | 5 +- crates/uv-pep440/Cargo.toml | 3 +- crates/uv-pep440/src/lib.rs | 4 + .../src/version_ranges_specifier.rs} | 83 +++++++++++-------- crates/uv-pep508/Cargo.toml | 1 - crates/uv-pep508/src/marker/algebra.rs | 9 +- crates/uv-pubgrub/Cargo.toml | 18 ---- crates/uv-resolver/Cargo.toml | 1 - crates/uv-resolver/src/error.rs | 8 +- crates/uv-resolver/src/lib.rs | 1 - .../uv-resolver/src/pubgrub/dependencies.rs | 6 +- crates/uv-resolver/src/pubgrub/mod.rs | 1 - crates/uv-resolver/src/requires_python.rs | 32 +++---- crates/uv-resolver/src/resolver/mod.rs | 10 ++- crates/uv/src/commands/pip/operations.rs | 2 +- 18 files changed, 96 insertions(+), 106 deletions(-) rename crates/{uv-pubgrub/src/lib.rs => uv-pep440/src/version_ranges_specifier.rs} (81%) delete mode 100644 crates/uv-pubgrub/Cargo.toml diff --git a/Cargo.lock b/Cargo.lock index 01d76f13d4b7..a9dd8f59a13e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4303,7 +4303,6 @@ dependencies = [ "uv-normalize", "uv-pep440", "uv-pep508", - "uv-pubgrub", "uv-pypi-types", "uv-warnings", "walkdir", @@ -4875,6 +4874,7 @@ dependencies = [ "tracing", "unicode-width", "unscanny", + "version-ranges", ] [[package]] @@ -4900,7 +4900,6 @@ dependencies = [ "uv-fs", "uv-normalize", "uv-pep440", - "uv-pubgrub", "version-ranges", ] @@ -4929,16 +4928,6 @@ dependencies = [ "thiserror", ] -[[package]] -name = "uv-pubgrub" -version = "0.0.1" -dependencies = [ - "itertools 0.13.0", - "thiserror", - "uv-pep440", - "version-ranges", -] - [[package]] name = "uv-publish" version = "0.1.0" @@ -5158,7 +5147,6 @@ dependencies = [ "uv-pep440", "uv-pep508", "uv-platform-tags", - "uv-pubgrub", "uv-pypi-types", "uv-python", "uv-requirements-txt", diff --git a/Cargo.toml b/Cargo.toml index 8b03754a9fd1..e02a6ae63def 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -46,10 +46,9 @@ uv-metadata = { path = "crates/uv-metadata" } uv-normalize = { path = "crates/uv-normalize" } uv-once-map = { path = "crates/uv-once-map" } uv-options-metadata = { path = "crates/uv-options-metadata" } -uv-pep440 = { path = "crates/uv-pep440", features = ["tracing", "rkyv"] } +uv-pep440 = { path = "crates/uv-pep440", features = ["tracing", "rkyv", "version-ranges"] } uv-pep508 = { path = "crates/uv-pep508", features = ["non-pep508-extensions"] } uv-platform-tags = { path = "crates/uv-platform-tags" } -uv-pubgrub = { path = "crates/uv-pubgrub" } uv-publish = { path = "crates/uv-publish" } uv-pypi-types = { path = "crates/uv-pypi-types" } uv-python = { path = "crates/uv-python" } diff --git a/crates/uv-build-backend/Cargo.toml b/crates/uv-build-backend/Cargo.toml index a6fa3d51c6a2..a13c50e759e1 100644 --- a/crates/uv-build-backend/Cargo.toml +++ b/crates/uv-build-backend/Cargo.toml @@ -18,7 +18,6 @@ uv-fs = { workspace = true } uv-normalize = { workspace = true } uv-pep440 = { workspace = true } uv-pep508 = { workspace = true } -uv-pubgrub = { workspace = true } uv-pypi-types = { workspace = true } uv-warnings = { workspace = true } diff --git a/crates/uv-build-backend/src/metadata.rs b/crates/uv-build-backend/src/metadata.rs index 470890fde996..d3ed665d2787 100644 --- a/crates/uv-build-backend/src/metadata.rs +++ b/crates/uv-build-backend/src/metadata.rs @@ -9,9 +9,8 @@ use std::str::FromStr; use tracing::debug; use uv_fs::Simplified; use uv_normalize::{ExtraName, PackageName}; -use uv_pep440::{Version, VersionSpecifiers}; +use uv_pep440::{Version, VersionRangesSpecifier, VersionSpecifiers}; use uv_pep508::{Requirement, VersionOrUrl}; -use uv_pubgrub::PubGrubSpecifier; use uv_pypi_types::{Metadata23, VerbatimParsedUrl}; use uv_warnings::warn_user_once; @@ -135,7 +134,7 @@ impl PyProjectToml { ); passed = false; } - PubGrubSpecifier::from_pep440_specifiers(specifier) + VersionRangesSpecifier::from_pep440_specifiers(specifier) .ok() .and_then(|specifier| Some(specifier.bounding_range()?.1 != Bound::Unbounded)) .unwrap_or(false) diff --git a/crates/uv-pep440/Cargo.toml b/crates/uv-pep440/Cargo.toml index 001009c02ef7..2afc944a962d 100644 --- a/crates/uv-pep440/Cargo.toml +++ b/crates/uv-pep440/Cargo.toml @@ -20,11 +20,12 @@ doctest = false workspace = true [dependencies] -serde = { workspace = true, features = ["derive"] } rkyv = { workspace = true, optional = true } +serde = { workspace = true, features = ["derive"] } tracing = { workspace = true, optional = true } unicode-width = { workspace = true } unscanny = { workspace = true } +version-ranges = { workspace = true, optional = true } [dev-dependencies] indoc = { version = "2.0.5" } diff --git a/crates/uv-pep440/src/lib.rs b/crates/uv-pep440/src/lib.rs index ca848d382e0a..14bc8f05a298 100644 --- a/crates/uv-pep440/src/lib.rs +++ b/crates/uv-pep440/src/lib.rs @@ -23,6 +23,8 @@ //! the version matching needs to catch all sorts of special cases #![warn(missing_docs)] +#[cfg(feature = "version-ranges")] +pub use version_ranges_specifier::{VersionRangesSpecifier, VersionRangesSpecifierError}; pub use { version::{ LocalSegment, Operator, OperatorParseError, Prerelease, PrereleaseKind, Version, @@ -39,3 +41,5 @@ mod version_specifier; #[cfg(test)] mod tests; +#[cfg(feature = "version-ranges")] +mod version_ranges_specifier; diff --git a/crates/uv-pubgrub/src/lib.rs b/crates/uv-pep440/src/version_ranges_specifier.rs similarity index 81% rename from crates/uv-pubgrub/src/lib.rs rename to crates/uv-pep440/src/version_ranges_specifier.rs index 5c19f185a352..0efa2112afd4 100644 --- a/crates/uv-pubgrub/src/lib.rs +++ b/crates/uv-pep440/src/version_ranges_specifier.rs @@ -1,58 +1,73 @@ +use std::error::Error; +use std::fmt::{Display, Formatter}; use std::ops::Bound; -use itertools::Itertools; -use thiserror::Error; use version_ranges::Ranges; -use uv_pep440::{Operator, Prerelease, Version, VersionSpecifier, VersionSpecifiers}; +use crate::{Operator, Prerelease, Version, VersionSpecifier, VersionSpecifiers}; -#[derive(Debug, Error)] -pub enum PubGrubSpecifierError { - #[error("~= operator requires at least two release segments: `{0}`")] +/// The conversion between PEP 440 [`VersionSpecifier`] and version-ranges +/// [`VersionRangesSpecifier`] failed. +#[derive(Debug)] +pub enum VersionRangesSpecifierError { + /// The `~=` operator requires at least two release segments InvalidTildeEquals(VersionSpecifier), } +impl Error for VersionRangesSpecifierError {} + +impl Display for VersionRangesSpecifierError { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + match self { + Self::InvalidTildeEquals(specifier) => { + write!( + f, + "The `~=` operator requires at least two release segments: `{specifier}`" + ) + } + } + } +} + /// A range of versions that can be used to satisfy a requirement. #[derive(Debug)] -pub struct PubGrubSpecifier(Ranges); +pub struct VersionRangesSpecifier(Ranges); -impl PubGrubSpecifier { - /// Returns an iterator over the bounds of the [`PubGrubSpecifier`]. +impl VersionRangesSpecifier { + /// Returns an iterator over the bounds of the [`VersionRangesSpecifier`]. pub fn iter(&self) -> impl Iterator, &Bound)> { self.0.iter() } - /// Return the bounding [`Ranges`] of the [`PubGrubSpecifier`]. + /// Return the bounding [`Ranges`] of the [`VersionRangesSpecifier`]. pub fn bounding_range(&self) -> Option<(Bound<&Version>, Bound<&Version>)> { self.0.bounding_range() } } -impl From> for PubGrubSpecifier { +impl From> for VersionRangesSpecifier { fn from(range: Ranges) -> Self { - PubGrubSpecifier(range) + VersionRangesSpecifier(range) } } -impl From for Ranges { +impl From for Ranges { /// Convert a PubGrub specifier to a range of versions. - fn from(specifier: PubGrubSpecifier) -> Self { + fn from(specifier: VersionRangesSpecifier) -> Self { specifier.0 } } -impl PubGrubSpecifier { +impl VersionRangesSpecifier { /// Convert [`VersionSpecifiers`] to a PubGrub-compatible version range, using PEP 440 /// semantics. pub fn from_pep440_specifiers( specifiers: &VersionSpecifiers, - ) -> Result { - let range = specifiers - .iter() - .map(Self::from_pep440_specifier) - .fold_ok(Ranges::full(), |range, specifier| { - range.intersection(&specifier.into()) - })?; + ) -> Result { + let mut range = Ranges::full(); + for specifier in specifiers.iter() { + range = range.intersection(&Self::from_pep440_specifier(specifier)?.into()); + } Ok(Self(range)) } @@ -60,7 +75,7 @@ impl PubGrubSpecifier { /// semantics. pub fn from_pep440_specifier( specifier: &VersionSpecifier, - ) -> Result { + ) -> Result { let ranges = match specifier.operator() { Operator::Equal => { let version = specifier.version().clone(); @@ -76,7 +91,9 @@ impl PubGrubSpecifier { } Operator::TildeEqual => { let [rest @ .., last, _] = specifier.version().release() else { - return Err(PubGrubSpecifierError::InvalidTildeEquals(specifier.clone())); + return Err(VersionRangesSpecifierError::InvalidTildeEquals( + specifier.clone(), + )); }; let upper = Version::new(rest.iter().chain([&(last + 1)])) .with_epoch(specifier.version().epoch()) @@ -167,13 +184,11 @@ impl PubGrubSpecifier { /// See: pub fn from_release_specifiers( specifiers: &VersionSpecifiers, - ) -> Result { - let range = specifiers - .iter() - .map(Self::from_release_specifier) - .fold_ok(Ranges::full(), |range, specifier| { - range.intersection(&specifier.into()) - })?; + ) -> Result { + let mut range = Ranges::full(); + for specifier in specifiers.iter() { + range = range.intersection(&Self::from_release_specifier(specifier)?.into()); + } Ok(Self(range)) } @@ -190,7 +205,7 @@ impl PubGrubSpecifier { /// See: pub fn from_release_specifier( specifier: &VersionSpecifier, - ) -> Result { + ) -> Result { let ranges = match specifier.operator() { Operator::Equal => { let version = specifier.version().only_release(); @@ -206,7 +221,9 @@ impl PubGrubSpecifier { } Operator::TildeEqual => { let [rest @ .., last, _] = specifier.version().release() else { - return Err(PubGrubSpecifierError::InvalidTildeEquals(specifier.clone())); + return Err(VersionRangesSpecifierError::InvalidTildeEquals( + specifier.clone(), + )); }; let upper = Version::new(rest.iter().chain([&(last + 1)])); let version = specifier.version().only_release(); diff --git a/crates/uv-pep508/Cargo.toml b/crates/uv-pep508/Cargo.toml index 4ba89682b318..f310fede96e6 100644 --- a/crates/uv-pep508/Cargo.toml +++ b/crates/uv-pep508/Cargo.toml @@ -24,7 +24,6 @@ workspace = true uv-fs = { workspace = true } uv-normalize = { workspace = true } uv-pep440 = { workspace = true } -uv-pubgrub = { workspace = true } boxcar = { workspace = true } indexmap = { workspace = true } diff --git a/crates/uv-pep508/src/marker/algebra.rs b/crates/uv-pep508/src/marker/algebra.rs index e41a49b5497a..a8f8f737ae3b 100644 --- a/crates/uv-pep508/src/marker/algebra.rs +++ b/crates/uv-pep508/src/marker/algebra.rs @@ -53,9 +53,8 @@ use std::sync::MutexGuard; use itertools::Either; use rustc_hash::FxHashMap; use std::sync::LazyLock; -use uv_pep440::Operator; +use uv_pep440::{Operator, VersionRangesSpecifier}; use uv_pep440::{Version, VersionSpecifier}; -use uv_pubgrub::PubGrubSpecifier; use version_ranges::Ranges; use crate::marker::MarkerValueExtra; @@ -746,7 +745,8 @@ impl Edges { /// Returns the [`Edges`] for a version specifier. fn from_specifier(specifier: VersionSpecifier) -> Edges { let specifier = - PubGrubSpecifier::from_release_specifier(&normalize_specifier(specifier)).unwrap(); + VersionRangesSpecifier::from_release_specifier(&normalize_specifier(specifier)) + .unwrap(); Edges::Version { edges: Edges::from_range(&specifier.into()), } @@ -764,7 +764,8 @@ impl Edges { let specifier = VersionSpecifier::equals_version(version.clone()); let specifier = python_version_to_full_version(specifier)?; let pubgrub_specifier = - PubGrubSpecifier::from_release_specifier(&normalize_specifier(specifier)).unwrap(); + VersionRangesSpecifier::from_release_specifier(&normalize_specifier(specifier)) + .unwrap(); range = range.union(&pubgrub_specifier.into()); } diff --git a/crates/uv-pubgrub/Cargo.toml b/crates/uv-pubgrub/Cargo.toml deleted file mode 100644 index ec44c72b4f7c..000000000000 --- a/crates/uv-pubgrub/Cargo.toml +++ /dev/null @@ -1,18 +0,0 @@ -[package] -name = "uv-pubgrub" -version = "0.0.1" -edition = "2021" -description = "Common uv pubgrub types." - -[lib] -doctest = false - -[lints] -workspace = true - -[dependencies] -uv-pep440 = { workspace = true } - -itertools = { workspace = true } -thiserror = { workspace = true } -version-ranges = { workspace = true } diff --git a/crates/uv-resolver/Cargo.toml b/crates/uv-resolver/Cargo.toml index 2c04a0327dfa..6a881fa9bc16 100644 --- a/crates/uv-resolver/Cargo.toml +++ b/crates/uv-resolver/Cargo.toml @@ -30,7 +30,6 @@ uv-once-map = { workspace = true } uv-pep440 = { workspace = true } uv-pep508 = { workspace = true } uv-platform-tags = { workspace = true } -uv-pubgrub = { workspace = true } uv-pypi-types = { workspace = true } uv-python = { workspace = true } uv-requirements-txt = { workspace = true } diff --git a/crates/uv-resolver/src/error.rs b/crates/uv-resolver/src/error.rs index 73f8bc634abb..3b4301cd8dd3 100644 --- a/crates/uv-resolver/src/error.rs +++ b/crates/uv-resolver/src/error.rs @@ -9,9 +9,7 @@ use rustc_hash::FxHashMap; use crate::candidate_selector::CandidateSelector; use crate::dependency_provider::UvDependencyProvider; use crate::fork_urls::ForkUrls; -use crate::pubgrub::{ - PubGrubPackage, PubGrubPackageInner, PubGrubReportFormatter, PubGrubSpecifierError, -}; +use crate::pubgrub::{PubGrubPackage, PubGrubPackageInner, PubGrubReportFormatter}; use crate::python_requirement::PythonRequirement; use crate::resolution::ConflictingDistributionError; use crate::resolver::{IncompletePackage, ResolverMarkers, UnavailablePackage, UnavailableReason}; @@ -21,7 +19,7 @@ use uv_distribution_types::{ BuiltDist, IndexCapabilities, IndexLocations, IndexUrl, InstalledDist, SourceDist, }; use uv_normalize::PackageName; -use uv_pep440::Version; +use uv_pep440::{Version, VersionRangesSpecifierError}; use uv_pep508::MarkerTree; use uv_static::EnvVars; @@ -40,7 +38,7 @@ pub enum ResolveError { UnregisteredTask(String), #[error(transparent)] - PubGrubSpecifier(#[from] PubGrubSpecifierError), + VersionRangesSpecifier(#[from] VersionRangesSpecifierError), #[error("Overrides contain conflicting URLs for package `{0}`:\n- {1}\n- {2}")] ConflictingOverrideUrls(PackageName, String, String), diff --git a/crates/uv-resolver/src/lib.rs b/crates/uv-resolver/src/lib.rs index eb9c6a62e0a1..008cbdd79a2a 100644 --- a/crates/uv-resolver/src/lib.rs +++ b/crates/uv-resolver/src/lib.rs @@ -11,7 +11,6 @@ pub use manifest::Manifest; pub use options::{Flexibility, Options, OptionsBuilder}; pub use preferences::{Preference, PreferenceError, Preferences}; pub use prerelease::PrereleaseMode; -pub use pubgrub::{PubGrubSpecifier, PubGrubSpecifierError}; pub use python_requirement::PythonRequirement; pub use requires_python::{RequiresPython, RequiresPythonError, RequiresPythonRange}; pub use resolution::{ diff --git a/crates/uv-resolver/src/pubgrub/dependencies.rs b/crates/uv-resolver/src/pubgrub/dependencies.rs index 5045e94a0ec2..788e4d9390a8 100644 --- a/crates/uv-resolver/src/pubgrub/dependencies.rs +++ b/crates/uv-resolver/src/pubgrub/dependencies.rs @@ -5,14 +5,14 @@ use pubgrub::Range; use tracing::warn; use uv_normalize::{ExtraName, PackageName}; -use uv_pep440::{Version, VersionSpecifiers}; +use uv_pep440::{Version, VersionRangesSpecifier, VersionSpecifiers}; use uv_pypi_types::{ ParsedArchiveUrl, ParsedDirectoryUrl, ParsedGitUrl, ParsedPathUrl, ParsedUrl, Requirement, RequirementSource, VerbatimParsedUrl, }; use crate::pubgrub::{PubGrubPackage, PubGrubPackageInner}; -use crate::{PubGrubSpecifier, ResolveError}; +use crate::ResolveError; #[derive(Clone, Debug, Eq, PartialEq)] pub(crate) struct PubGrubDependency { @@ -179,7 +179,7 @@ impl PubGrubRequirement { extra: Option, requirement: &Requirement, ) -> Result { - let version = PubGrubSpecifier::from_pep440_specifiers(specifier)?.into(); + let version = VersionRangesSpecifier::from_pep440_specifiers(specifier)?.into(); let requirement = Self { package: PubGrubPackage::from_package( diff --git a/crates/uv-resolver/src/pubgrub/mod.rs b/crates/uv-resolver/src/pubgrub/mod.rs index d6aa611f3d86..13824ad07a40 100644 --- a/crates/uv-resolver/src/pubgrub/mod.rs +++ b/crates/uv-resolver/src/pubgrub/mod.rs @@ -3,7 +3,6 @@ pub(crate) use crate::pubgrub::distribution::PubGrubDistribution; pub(crate) use crate::pubgrub::package::{PubGrubPackage, PubGrubPackageInner, PubGrubPython}; pub(crate) use crate::pubgrub::priority::{PubGrubPriorities, PubGrubPriority}; pub(crate) use crate::pubgrub::report::PubGrubReportFormatter; -pub use uv_pubgrub::{PubGrubSpecifier, PubGrubSpecifierError}; mod dependencies; mod distribution; diff --git a/crates/uv-resolver/src/requires_python.rs b/crates/uv-resolver/src/requires_python.rs index 4d8592be004e..e820b31c1ae5 100644 --- a/crates/uv-resolver/src/requires_python.rs +++ b/crates/uv-resolver/src/requires_python.rs @@ -5,14 +5,16 @@ use std::collections::Bound; use std::ops::Deref; use uv_distribution_filename::WheelFilename; -use uv_pep440::{Version, VersionSpecifier, VersionSpecifiers}; +use uv_pep440::{ + Version, VersionRangesSpecifier, VersionRangesSpecifierError, VersionSpecifier, + VersionSpecifiers, +}; use uv_pep508::{MarkerExpression, MarkerTree, MarkerValueVersion}; -use uv_pubgrub::PubGrubSpecifier; #[derive(thiserror::Error, Debug)] pub enum RequiresPythonError { #[error(transparent)] - PubGrub(#[from] crate::pubgrub::PubGrubSpecifierError), + VersionRangesSpecifier(#[from] VersionRangesSpecifierError), } /// The `Requires-Python` requirement specifier. @@ -53,10 +55,11 @@ impl RequiresPython { /// Returns a [`RequiresPython`] from a version specifier. pub fn from_specifiers(specifiers: &VersionSpecifiers) -> Result { - let (lower_bound, upper_bound) = PubGrubSpecifier::from_release_specifiers(specifiers)? - .bounding_range() - .map(|(lower_bound, upper_bound)| (lower_bound.cloned(), upper_bound.cloned())) - .unwrap_or((Bound::Unbounded, Bound::Unbounded)); + let (lower_bound, upper_bound) = + VersionRangesSpecifier::from_release_specifiers(specifiers)? + .bounding_range() + .map(|(lower_bound, upper_bound)| (lower_bound.cloned(), upper_bound.cloned())) + .unwrap_or((Bound::Unbounded, Bound::Unbounded)); Ok(Self { specifiers: specifiers.clone(), range: RequiresPythonRange(LowerBound(lower_bound), UpperBound(upper_bound)), @@ -72,7 +75,7 @@ impl RequiresPython { // Convert to PubGrub range and perform an intersection. let range = specifiers .into_iter() - .map(PubGrubSpecifier::from_release_specifiers) + .map(VersionRangesSpecifier::from_release_specifiers) .fold_ok(None, |range: Option>, requires_python| { if let Some(range) = range { Some(range.intersection(&requires_python.into())) @@ -237,7 +240,7 @@ impl RequiresPython { /// provided range. However, `>=3.9` would not be considered compatible, as the /// `Requires-Python` includes Python 3.8, but `>=3.9` does not. pub fn is_contained_by(&self, target: &VersionSpecifiers) -> bool { - let Ok(target) = PubGrubSpecifier::from_release_specifiers(target) else { + let Ok(target) = VersionRangesSpecifier::from_release_specifiers(target) else { return false; }; let target = target @@ -485,11 +488,12 @@ impl serde::Serialize for RequiresPython { impl<'de> serde::Deserialize<'de> for RequiresPython { fn deserialize>(deserializer: D) -> Result { let specifiers = VersionSpecifiers::deserialize(deserializer)?; - let (lower_bound, upper_bound) = PubGrubSpecifier::from_release_specifiers(&specifiers) - .map_err(serde::de::Error::custom)? - .bounding_range() - .map(|(lower_bound, upper_bound)| (lower_bound.cloned(), upper_bound.cloned())) - .unwrap_or((Bound::Unbounded, Bound::Unbounded)); + let (lower_bound, upper_bound) = + VersionRangesSpecifier::from_release_specifiers(&specifiers) + .map_err(serde::de::Error::custom)? + .bounding_range() + .map(|(lower_bound, upper_bound)| (lower_bound.cloned(), upper_bound.cloned())) + .unwrap_or((Bound::Unbounded, Bound::Unbounded)); Ok(Self { specifiers, range: RequiresPythonRange(LowerBound(lower_bound), UpperBound(upper_bound)), diff --git a/crates/uv-resolver/src/resolver/mod.rs b/crates/uv-resolver/src/resolver/mod.rs index 7ca4651184bb..077d4934d874 100644 --- a/crates/uv-resolver/src/resolver/mod.rs +++ b/crates/uv-resolver/src/resolver/mod.rs @@ -34,7 +34,7 @@ use uv_distribution_types::{ }; use uv_git::GitResolver; use uv_normalize::{ExtraName, GroupName, PackageName}; -use uv_pep440::{Version, MIN_VERSION}; +use uv_pep440::{Version, VersionRangesSpecifier, MIN_VERSION}; use uv_pep508::MarkerTree; use uv_platform_tags::Tags; use uv_pypi_types::{Requirement, ResolutionMetadata, VerbatimParsedUrl}; @@ -51,7 +51,7 @@ use crate::pins::FilePins; use crate::preferences::Preferences; use crate::pubgrub::{ PubGrubDependency, PubGrubDistribution, PubGrubPackage, PubGrubPackageInner, PubGrubPriorities, - PubGrubPython, PubGrubSpecifier, + PubGrubPython, }; use crate::python_requirement::PythonRequirement; use crate::resolution::ResolutionGraph; @@ -2224,7 +2224,9 @@ impl ForkState { Locals::map(local, specifier) .map_err(ResolveError::InvalidVersion) .and_then(|specifier| { - Ok(PubGrubSpecifier::from_pep440_specifier(&specifier)?) + Ok(VersionRangesSpecifier::from_pep440_specifier( + &specifier, + )?) }) }) .fold_ok(Range::full(), |range, specifier| { @@ -2300,7 +2302,7 @@ impl ForkState { ) = reason { let python_version: Range = - PubGrubSpecifier::from_release_specifiers(&requires_python)?.into(); + VersionRangesSpecifier::from_release_specifiers(&requires_python)?.into(); let package = &self.next; self.pubgrub diff --git a/crates/uv/src/commands/pip/operations.rs b/crates/uv/src/commands/pip/operations.rs index 7b30ece08842..1eef37c1a7d5 100644 --- a/crates/uv/src/commands/pip/operations.rs +++ b/crates/uv/src/commands/pip/operations.rs @@ -773,5 +773,5 @@ pub(crate) enum Error { Anyhow(#[from] anyhow::Error), #[error(transparent)] - PubGrubSpecifier(#[from] uv_resolver::PubGrubSpecifierError), + VersionRangesSpecifier(#[from] uv_pep440::VersionRangesSpecifierError), }