mirrors/uv
1
0
Fork 0
mirror of https://github.com/astral-sh/uv.git synced 2025-11-01 20:31:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Make target Python version an optional field (#4000)

Browse source 
## Summary

Instead of checking if the target and installed version are the same, we
model the data such that the target version is only present if it was
specified by the user. This also means that we correctly say "requested
version" even if the two happen to be the same.
This commit is contained in:
Charlie Marsh 2024-06-03 18:37:15 -04:00 • committed by GitHub
parent 037e7e345c
commit 77e93157fb
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 61 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/bench/benches/uv.rs
View file

@ -136,7 +136,7 @@ mod resolver {
let index_locations = IndexLocations::default();
let installed_packages = EmptyInstalledPackages;
let interpreter = venv.interpreter();
let python_requirement = PythonRequirement::from_marker_environment(interpreter, &MARKERS);
let python_requirement = PythonRequirement::from_interpreter(interpreter);
let build_context = BuildDispatch::new(
client,

3
crates/uv-dispatch/src/lib.rs
View file

@ -150,9 +150,8 @@ impl<'a> BuildContext for BuildDispatch<'a> {
}
async fn resolve<'data>(&'data self, requirements: &'data [Requirement]) -> Result<Resolution> {
let python_requirement = PythonRequirement::from_interpreter(self.interpreter);
let markers = self.interpreter.markers();
let python_requirement =
PythonRequirement::from_marker_environment(self.interpreter, markers);
let tags = self.interpreter.tags()?;
let resolver = Resolver::new(
Manifest::simple(requirements.to_vec()),

14
crates/uv-resolver/src/pubgrub/report.rs
View file

@ -49,11 +49,17 @@ impl ReportFormatter<PubGrubPackage, Range<Version>, UnavailableReason>
&**package,
PubGrubPackageInner::Python(PubGrubPython::Target)
) {
return format!(
"the requested {package} version ({}) does not satisfy {}",
python.target(),
return if let Some(target) = python.target() {
format!(
"the requested {package} version ({target}) does not satisfy {}",
PackageRange::compatibility(package, set)
);
)
} else {
format!(
"the requested {package} version does not satisfy {}",
PackageRange::compatibility(package, set)
)
};
}
if matches!(
&**package,

24
crates/uv-resolver/src/python_requirement.rs
View file

@ -1,5 +1,5 @@
use pep508_rs::{MarkerEnvironment, StringVersion};
use uv_interpreter::Interpreter;
use pep508_rs::StringVersion;
use uv_interpreter::{Interpreter, PythonVersion};
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct PythonRequirement {
@ -8,21 +8,29 @@ pub struct PythonRequirement {
/// The target version of Python; that is, the version of Python for which we are resolving
/// dependencies. This is typically the same as the installed version, but may be different
/// when specifying an alternate Python version for the resolution.
target: StringVersion,
///
/// If `None`, the target version is the same as the installed version.
target: Option<StringVersion>,
}
impl PythonRequirement {
pub fn from_marker_environment(interpreter: &Interpreter, env: &MarkerEnvironment) -> Self {
/// Create a [`PythonRequirement`] to resolve against both an [`Interpreter`] and a
/// [`PythonVersion`].
pub fn from_python_version(interpreter: &Interpreter, python_version: &PythonVersion) -> Self {
Self {
installed: interpreter.python_full_version().clone(),
target: env.python_full_version().clone(),
target: Some(StringVersion {
string: python_version.to_string(),
version: python_version.python_full_version(),
}),
}
}
/// Create a [`PythonRequirement`] to resolve against an [`Interpreter`].
pub fn from_interpreter(interpreter: &Interpreter) -> Self {
Self {
installed: interpreter.python_full_version().clone(),
target: interpreter.python_full_version().clone(),
target: None,
}
}
@ -32,7 +40,7 @@ impl PythonRequirement {
}
/// Return the target version of Python.
pub fn target(&self) -> &StringVersion {
&self.target
pub fn target(&self) -> Option<&StringVersion> {
self.target.as_ref()
}
}

10
crates/uv-resolver/src/resolver/mod.rs
View file

@ -308,7 +308,9 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
debug!(
"Solving with target Python version {}",
self.python_requirement.target()
self.python_requirement
.target()
.unwrap_or(self.python_requirement.installed())
);
'FORK: while let Some(mut state) = forked_states.pop() {
@ -715,9 +717,7 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
// The version is incompatible due to its Python requirement.
if let Some(requires_python) = metadata.requires_python.as_ref() {
let installed = self.python_requirement.installed();
let target = self.python_requirement.target();
if target != installed {
if let Some(target) = self.python_requirement.target() {
if !requires_python.contains(target) {
return Ok(Some(ResolverVersion::Unavailable(
version.clone(),
@ -730,6 +730,8 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
)));
}
}
let installed = self.python_requirement.installed();
if !requires_python.contains(installed) {
return Ok(Some(ResolverVersion::Unavailable(
version.clone(),

15
crates/uv-resolver/src/version_map.rs
View file

@ -466,8 +466,8 @@ impl VersionMapLazy {
// Source distributions must meet both the _target_ Python version and the
// _installed_ Python version (to build successfully)
if let Some(requires_python) = requires_python {
if self.python_requirement.target() != self.python_requirement.installed() {
if !requires_python.contains(self.python_requirement.target()) {
if let Some(target) = self.python_requirement.target() {
if !requires_python.contains(target) {
return SourceDistCompatibility::Incompatible(
IncompatibleSource::RequiresPython(
requires_python,
@ -533,12 +533,21 @@ impl VersionMapLazy {
// Check for a Python version incompatibility`
if let Some(requires_python) = requires_python {
if !requires_python.contains(self.python_requirement.target()) {
if let Some(target) = self.python_requirement.target() {
if !requires_python.contains(target) {
return WheelCompatibility::Incompatible(IncompatibleWheel::RequiresPython(
requires_python,
PythonRequirementKind::Target,
));
}
} else {
if !requires_python.contains(self.python_requirement.installed()) {
return WheelCompatibility::Incompatible(IncompatibleWheel::RequiresPython(
requires_python,
PythonRequirementKind::Installed,
));
}
}
}
// Determine a compatibility for the wheel based on tags.

2
crates/uv-resolver/tests/resolver.rs
View file

@ -146,7 +146,7 @@ async fn resolve(
.expect("Python should be installed")
.into_interpreter();
let interpreter = Interpreter::artificial(real_interpreter.platform().clone(), markers.clone());
let python_requirement = PythonRequirement::from_marker_environment(&interpreter, markers);
let python_requirement = PythonRequirement::from_interpreter(&interpreter);
let cache = Cache::temp().unwrap().init().unwrap();
let build_context = DummyContext::new(cache, interpreter.clone());
let hashes = HashStrategy::None;

9
crates/uv/src/commands/pip/compile.rs
View file

@ -215,6 +215,13 @@ pub(crate) async fn pip_compile(
InMemoryIndexRef::Borrowed(&source_index)
};
// Determine the Python requirement, based on the interpreter and the requested version.
let python_requirement = if let Some(python_version) = python_version.as_ref() {
PythonRequirement::from_python_version(&interpreter, python_version)
} else {
PythonRequirement::from_interpreter(&interpreter)
};
// Determine the tags, markers, and interpreter to use for resolution.
let tags = match (python_platform, python_version.as_ref()) {
(Some(python_platform), Some(python_version)) => Cow::Owned(Tags::from_env(
@ -251,8 +258,6 @@ pub(crate) async fn pip_compile(
(None, None) => Cow::Borrowed(interpreter.markers()),
};
let python_requirement = PythonRequirement::from_marker_environment(&interpreter, &markers);
// Generate, but don't enforce hashes for the requirements.
let hasher = if generate_hashes {
HashStrategy::Generate

7
crates/uv/src/commands/pip/operations.rs
View file

@ -182,11 +182,6 @@ pub(crate) async fn resolve<InstalledPackages: InstalledPackagesProvider>(
// Collect constraints and overrides.
let constraints = Constraints::from_requirements(constraints);
let overrides = Overrides::from_requirements(overrides);
let python_requirement = if let Some(markers) = markers {
PythonRequirement::from_marker_environment(interpreter, markers)
} else {
PythonRequirement::from_interpreter(interpreter)
};
// Determine any lookahead requirements.
let lookaheads = match options.dependency_mode {
@ -206,6 +201,8 @@ pub(crate) async fn resolve<InstalledPackages: InstalledPackagesProvider>(
DependencyMode::Direct => Vec::new(),
};
let python_requirement = PythonRequirement::from_interpreter(interpreter);
// TODO(zanieb): Consider consuming these instead of cloning
let exclusions = Exclusions::new(reinstall.clone(), upgrade.clone());