Rename UvRequirement -> Requirement, UvSource -> Source

Author: konstin

crates/distribution-types/src/resolution.rs

@@ -3,7 +3,7 @@ use rustc_hash::FxHashMap;
 use uv_normalize::PackageName;
 
 use crate::{
-    BuiltDist, Dist, Name, ParsedGitUrl, ResolvedDist, SourceDist, UvRequirement, UvSource,
+    BuiltDist, Dist, Name, ParsedGitUrl, Requirement, RequirementSource, ResolvedDist, SourceDist,
 };
 
 /// A set of packages pinned at specific versions.
@@ -57,10 +57,10 @@ impl Resolution {
         self.0.is_empty()
     }
 
-    /// Return the set of [`UvRequirement`]s that this resolution represents, exclusive of any
+    /// Return the set of [`Requirement`]s that this resolution represents, exclusive of any
     /// editable requirements.
-    pub fn requirements(&self) -> Vec<UvRequirement> {
-        let mut requirements: Vec<UvRequirement> = self
+    pub fn requirements(&self) -> Vec<Requirement> {
+        let mut requirements: Vec<Requirement> = self
             .0
             .values()
             // Remove editable requirements
@@ -72,59 +72,59 @@ impl Resolution {
     }
 }
 
-impl From<&ResolvedDist> for UvRequirement {
+impl From<&ResolvedDist> for Requirement {
     fn from(resolved_dist: &ResolvedDist) -> Self {
         let source = match resolved_dist {
             ResolvedDist::Installable(dist) => match dist {
-                Dist::Built(BuiltDist::Registry(wheel)) => UvSource::Registry {
+                Dist::Built(BuiltDist::Registry(wheel)) => RequirementSource::Registry {
                     version: pep440_rs::VersionSpecifiers::from(
                         pep440_rs::VersionSpecifier::equals_version(wheel.filename.version.clone()),
                     ),
                     index: None,
                 },
-                Dist::Built(BuiltDist::DirectUrl(wheel)) => UvSource::Url {
+                Dist::Built(BuiltDist::DirectUrl(wheel)) => RequirementSource::Url {
                     url: wheel.url.clone(),
                     subdirectory: None,
                 },
-                Dist::Built(BuiltDist::Path(wheel)) => UvSource::Path {
+                Dist::Built(BuiltDist::Path(wheel)) => RequirementSource::Path {
                     path: wheel.path.clone(),
                     url: wheel.url.clone(),
                     editable: None,
                 },
-                Dist::Source(SourceDist::Registry(sdist)) => UvSource::Registry {
+                Dist::Source(SourceDist::Registry(sdist)) => RequirementSource::Registry {
                     version: pep440_rs::VersionSpecifiers::from(
                         pep440_rs::VersionSpecifier::equals_version(sdist.filename.version.clone()),
                     ),
                     index: None,
                 },
-                Dist::Source(SourceDist::DirectUrl(sdist)) => UvSource::Url {
+                Dist::Source(SourceDist::DirectUrl(sdist)) => RequirementSource::Url {
                     url: sdist.url.clone(),
                     subdirectory: None,
                 },
                 Dist::Source(SourceDist::Git(sdist)) => {
                     let git_url = ParsedGitUrl::try_from(sdist.url.raw())
                         .expect("urls must be valid at this point");
-                    UvSource::Git {
+                    RequirementSource::Git {
                         url: sdist.url.clone(),
                         repository: git_url.url.repository().clone(),
                         reference: git_url.url.reference().clone(),
                         subdirectory: git_url.subdirectory,
                     }
                 }
-                Dist::Source(SourceDist::Path(sdist)) => UvSource::Path {
+                Dist::Source(SourceDist::Path(sdist)) => RequirementSource::Path {
                     path: sdist.path.clone(),
                     url: sdist.url.clone(),
                     editable: None,
                 },
             },
-            ResolvedDist::Installed(dist) => UvSource::Registry {
+            ResolvedDist::Installed(dist) => RequirementSource::Registry {
                 version: pep440_rs::VersionSpecifiers::from(
                     pep440_rs::VersionSpecifier::equals_version(dist.version().clone()),
                 ),
                 index: None,
             },
         };
-        UvRequirement {
+        Requirement {
             name: resolved_dist.name().clone(),
             extras: vec![],
             marker: None,

crates/distribution-types/src/uv_requirement.rs

@@ -5,29 +5,29 @@ use indexmap::IndexMap;
 use url::Url;
 
 use pep440_rs::VersionSpecifiers;
-use pep508_rs::{MarkerEnvironment, MarkerTree, Requirement, VerbatimUrl, VersionOrUrl};
+use pep508_rs::{MarkerEnvironment, MarkerTree, VerbatimUrl, VersionOrUrl};
 use uv_git::GitReference;
 use uv_normalize::{ExtraName, PackageName};
 
 use crate::{ParsedUrl, ParsedUrlError};
 
 /// The requirements of a distribution, an extension over PEP 508's requirements.
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct UvRequirements {
-    pub dependencies: Vec<UvRequirement>,
-    pub optional_dependencies: IndexMap<ExtraName, Vec<UvRequirement>>,
+pub struct Requirements {
+    pub dependencies: Vec<Requirement>,
+    pub optional_dependencies: IndexMap<ExtraName, Vec<Requirement>>,
 }
 
 /// A representation of dependency on a package, an extension over a PEP 508's requirement.
 #[derive(Hash, Debug, Clone, Eq, PartialEq)]
-pub struct UvRequirement {
+pub struct Requirement {
     pub name: PackageName,
     pub extras: Vec<ExtraName>,
     pub marker: Option<MarkerTree>,
-    pub source: UvSource,
+    pub source: RequirementSource,
 }
 
-impl UvRequirement {
+impl Requirement {
     /// Returns whether the markers apply for the given environment.
     pub fn evaluate_markers(&self, env: &MarkerEnvironment, extras: &[ExtraName]) -> bool {
         if let Some(marker) = &self.marker {
@@ -37,23 +37,23 @@ impl UvRequirement {
         }
     }
 
-    pub fn from_requirement(requirement: Requirement) -> Result<Self, ParsedUrlError> {
+    pub fn from_requirement(requirement: pep508_rs::Requirement) -> Result<Self, ParsedUrlError> {
         let source = match requirement.version_or_url {
-            None => UvSource::Registry {
+            None => RequirementSource::Registry {
                 version: VersionSpecifiers::empty(),
                 index: None,
             },
             // The most popular case: Just a name, a version range and maybe extras.
-            Some(VersionOrUrl::VersionSpecifier(version)) => UvSource::Registry {
+            Some(VersionOrUrl::VersionSpecifier(version)) => RequirementSource::Registry {
                 version,
                 index: None,
             },
             Some(VersionOrUrl::Url(url)) => {
                 let direct_url = ParsedUrl::try_from(&url.to_url())?;
-                UvSource::from_parsed_url(direct_url, url)
+                RequirementSource::from_parsed_url(direct_url, url)
             }
         };
-        Ok(UvRequirement {
+        Ok(Requirement {
             name: requirement.name,
             extras: requirement.extras,
             marker: requirement.marker,
@@ -62,7 +62,7 @@ impl UvRequirement {
     }
 }
 
-impl Display for UvRequirement {
+impl Display for Requirement {
     /// Note: This is for user display, not for requirements.txt
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.name)?;
@@ -78,16 +78,16 @@ impl Display for UvRequirement {
             )?;
         }
         match &self.source {
-            UvSource::Registry { version, index } => {
+            RequirementSource::Registry { version, index } => {
                 write!(f, "{version}")?;
                 if let Some(index) = index {
                     write!(f, " (index: {index})")?;
                 }
             }
-            UvSource::Url { url, .. } => {
+            RequirementSource::Url { url, .. } => {
                 write!(f, " @ {url}")?;
             }
-            UvSource::Git {
+            RequirementSource::Git {
                 url: _,
                 repository,
                 reference,
@@ -101,7 +101,7 @@ impl Display for UvRequirement {
                     writeln!(f, "#subdirectory={}", subdirectory.display())?;
                 }
             }
-            UvSource::Path { url, .. } => {
+            RequirementSource::Path { url, .. } => {
                 write!(f, " @ {url}")?;
             }
         }
@@ -114,7 +114,7 @@ impl Display for UvRequirement {
 
 /// The different kinds of requirements (version specifier, HTTP(S) URL, git repository, path).
 #[derive(Hash, Debug, Clone, Eq, PartialEq)]
-pub enum UvSource {
+pub enum RequirementSource {
     /// The requirement has a version specifier, such as `foo >1,<2`.
     Registry {
         version: VersionSpecifiers,
@@ -154,21 +154,21 @@ pub enum UvSource {
     },
 }
 
-impl UvSource {
+impl RequirementSource {
     pub fn from_parsed_url(parsed_url: ParsedUrl, url: VerbatimUrl) -> Self {
         match parsed_url {
-            ParsedUrl::LocalFile(local_file) => UvSource::Path {
+            ParsedUrl::LocalFile(local_file) => RequirementSource::Path {
                 path: local_file.path,
                 url,
                 editable: None,
             },
-            ParsedUrl::Git(git) => UvSource::Git {
+            ParsedUrl::Git(git) => RequirementSource::Git {
                 url,
                 repository: git.url.repository().clone(),
                 reference: git.url.reference().clone(),
                 subdirectory: git.subdirectory,
             },
-            ParsedUrl::Archive(archive) => UvSource::Url {
+            ParsedUrl::Archive(archive) => RequirementSource::Url {
                 url,
                 subdirectory: archive.subdirectory,
             },

crates/requirements-txt/src/lib.rs

@@ -44,10 +44,10 @@ use tracing::instrument;
 use unscanny::{Pattern, Scanner};
 use url::Url;
 
-use distribution_types::{ParsedUrlError, UvRequirement};
+use distribution_types::{ParsedUrlError, Requirement};
 use pep508_rs::{
-    expand_env_vars, split_scheme, strip_host, Extras, Pep508Error, Pep508ErrorSource, Requirement,
-    Scheme, VerbatimUrl,
+    expand_env_vars, split_scheme, strip_host, Extras, Pep508Error, Pep508ErrorSource, Scheme,
+    VerbatimUrl,
 };
 #[cfg(feature = "http")]
 use uv_client::BaseClient;
@@ -311,7 +311,7 @@ pub struct RequirementsTxt {
     /// The actual requirements with the hashes.
     pub requirements: Vec<RequirementEntry>,
     /// Constraints included with `-c`.
-    pub constraints: Vec<UvRequirement>,
+    pub constraints: Vec<Requirement>,
     /// Editables with `-e`.
     pub editables: Vec<EditableRequirement>,
     /// The index URL, specified with `--index-url`.

crates/requirements-txt/src/requirement.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 
 use thiserror::Error;
 
-use distribution_types::{ParsedUrl, ParsedUrlError, UvRequirement, UvSource};
+use distribution_types::{ParsedUrl, ParsedUrlError, RequirementSource};
 use pep508_rs::{
     MarkerEnvironment, MarkerTree, Pep508Error, Pep508ErrorSource, UnnamedRequirement,
 };
@@ -16,7 +16,7 @@ use crate::Requirement;
 pub enum RequirementsTxtRequirement {
     /// The uv-specific superset over PEP 508 requirements specifier incorporating
     /// `tool.uv.sources`.
-    Uv(UvRequirement),
+    Uv(Requirement),
     /// A PEP 508-like, direct URL dependency specifier.
     Unnamed(UnnamedRequirement),
 }
@@ -64,21 +64,21 @@ impl RequirementsTxtRequirement {
     }
 
     /// Return the version specifier or URL for the requirement.
-    pub fn source(&self) -> UvSource {
+    pub fn source(&self) -> RequirementSource {
         // TODO(konsti): Error handling
         match self {
             Self::Uv(requirement) => requirement.source.clone(),
             Self::Unnamed(requirement) => {
                 let parsed_url = ParsedUrl::try_from(&requirement.url.to_url())
                     .expect("TODO(konsti): scheme not supported");
-                UvSource::from_parsed_url(parsed_url, requirement.url.clone())
+                RequirementSource::from_parsed_url(parsed_url, requirement.url.clone())
             }
         }
     }
 }
 
-impl From<UvRequirement> for RequirementsTxtRequirement {
-    fn from(requirement: UvRequirement) -> Self {
+impl From<Requirement> for RequirementsTxtRequirement {
+    fn from(requirement: Requirement) -> Self {
         Self::Uv(requirement)
     }
 }
@@ -104,9 +104,9 @@ impl RequirementsTxtRequirement {
         working_dir: impl AsRef<Path>,
     ) -> Result<Self, RequirementsTxtRequirementError> {
         // Attempt to parse as a PEP 508-compliant requirement.
-        match Requirement::parse(input, &working_dir) {
+        match pep508_rs::Requirement::parse(input, &working_dir) {
             Ok(requirement) => Ok(Self::Uv(
-                UvRequirement::from_requirement(requirement)
+                Requirement::from_requirement(requirement)
                     .map_err(|err| RequirementsTxtRequirementError::ParsedUrl(Box::new(err)))?,
             )),
             Err(err) => match err.message {

crates/uv-build/src/lib.rs

@@ -25,9 +25,9 @@ use tokio::process::Command;
 use tokio::sync::Mutex;
 use tracing::{debug, info_span, instrument, Instrument};
 
-use distribution_types::{ParsedUrlError, Resolution, UvRequirement};
+use distribution_types::{ParsedUrlError, Requirement, Resolution};
 use pep440_rs::Version;
-use pep508_rs::{PackageName, Requirement};
+use pep508_rs::PackageName;
 use uv_configuration::{BuildKind, ConfigSettings, SetupPyStrategy};
 use uv_fs::{PythonExt, Simplified};
 use uv_interpreter::{Interpreter, PythonEnvironment};
@@ -54,18 +54,20 @@ static WHEEL_NOT_FOUND_RE: Lazy<Regex> =
 static DEFAULT_BACKEND: Lazy<Pep517Backend> = Lazy::new(|| Pep517Backend {
     backend: "setuptools.build_meta:__legacy__".to_string(),
     backend_path: None,
-    requirements: vec![UvRequirement::from_requirement(
-        Requirement::from_str("setuptools >= 40.8.0").unwrap(),
+    requirements: vec![Requirement::from_requirement(
+        pep508_rs::Requirement::from_str("setuptools >= 40.8.0").unwrap(),
     )
     .unwrap()],
 });
 
 /// The requirements for `--legacy-setup-py` builds.
-static SETUP_PY_REQUIREMENTS: Lazy<[UvRequirement; 2]> = Lazy::new(|| {
+static SETUP_PY_REQUIREMENTS: Lazy<[Requirement; 2]> = Lazy::new(|| {
     [
-        UvRequirement::from_requirement(Requirement::from_str("setuptools >= 40.8.0").unwrap())
-            .unwrap(),
-        UvRequirement::from_requirement(Requirement::from_str("wheel").unwrap()).unwrap(),
+        Requirement::from_requirement(
+            pep508_rs::Requirement::from_str("setuptools >= 40.8.0").unwrap(),
+        )
+        .unwrap(),
+        Requirement::from_requirement(pep508_rs::Requirement::from_str("wheel").unwrap()).unwrap(),
     ]
 });
 
@@ -229,7 +231,7 @@ pub struct Project {
 #[serde(rename_all = "kebab-case")]
 pub struct BuildSystem {
     /// PEP 508 dependencies required to execute the build system.
-    pub requires: Vec<Requirement>,
+    pub requires: Vec<pep508_rs::Requirement>,
     /// A string naming a Python object that will be used to perform the build.
     pub build_backend: Option<String>,
     /// Specify that their backend code is hosted in-tree, this key contains a list of directories.
@@ -293,7 +295,7 @@ struct Pep517Backend {
     /// <https://peps.python.org/pep-0517/#build-wheel>
     backend: String,
     /// `build-backend.requirements` in pyproject.toml
-    requirements: Vec<UvRequirement>,
+    requirements: Vec<Requirement>,
     /// <https://peps.python.org/pep-0517/#in-tree-build-backends>
     backend_path: Option<BackendPath>,
 }
@@ -579,7 +581,7 @@ impl SourceBuild {
                         requirements: build_system
                             .requires
                             .into_iter()
-                            .map(UvRequirement::from_requirement)
+                            .map(Requirement::from_requirement)
                             .collect::<Result<_, _>>()
                             .map_err(|err| Box::new(Error::DirectUrl(err)))?,
                     }
@@ -953,7 +955,7 @@ async fn create_pep517_build_environment(
     })?;
 
     // Deserialize the requirements from the output file.
-    let extra_requires: Vec<Requirement> = serde_json::from_slice::<Vec<Requirement>>(&contents).map_err(|err| {
+    let extra_requires: Vec<pep508_rs::Requirement> = serde_json::from_slice::<Vec<pep508_rs::Requirement>>(&contents).map_err(|err| {
         Error::from_command_output(
             format!(
                 "Build backend failed to return extra requires with `get_requires_for_build_{build_kind}`: {err}"
@@ -962,9 +964,9 @@ async fn create_pep517_build_environment(
             version_id,
         )
     })?;
-    let extra_requires: Vec<UvRequirement> = extra_requires
+    let extra_requires: Vec<Requirement> = extra_requires
         .into_iter()
-        .map(UvRequirement::from_requirement)
+        .map(Requirement::from_requirement)
         .collect::<Result<_, _>>()
         .map_err(Error::DirectUrl)?;