Merge branch 'main' into local-version-semantics

Author: charliermarsh

crates/uv-bench/benches/uv.rs

@@ -101,7 +101,7 @@ mod resolver {
     use uv_python::Interpreter;
     use uv_resolver::{
         FlatIndex, InMemoryIndex, Manifest, OptionsBuilder, PythonRequirement, RequiresPython,
-        ResolutionGraph, Resolver, ResolverMarkers,
+        ResolutionGraph, Resolver, ResolverEnvironment,
     };
     use uv_types::{BuildIsolation, EmptyInstalledPackages, HashStrategy, InFlight};
 
@@ -198,9 +198,9 @@ mod resolver {
         );
 
         let markers = if universal {
-            ResolverMarkers::universal(vec![])
+            ResolverEnvironment::universal(vec![])
         } else {
-            ResolverMarkers::specific_environment(ResolverMarkerEnvironment::from(MARKERS.clone()))
+            ResolverEnvironment::specific(ResolverMarkerEnvironment::from(MARKERS.clone()))
         };
 
         let resolver = Resolver::new(

crates/uv-client/src/base_client.rs

@@ -1,13 +1,14 @@
 use itertools::Itertools;
 use reqwest::{Client, ClientBuilder, Response};
-use reqwest_middleware::ClientWithMiddleware;
+use reqwest_middleware::{ClientWithMiddleware, Middleware};
 use reqwest_retry::policies::ExponentialBackoff;
 use reqwest_retry::{
     DefaultRetryableStrategy, RetryTransientMiddleware, Retryable, RetryableStrategy,
 };
 use std::error::Error;
 use std::fmt::Debug;
 use std::path::Path;
+use std::sync::Arc;
 use std::time::Duration;
 use std::{env, iter};
 use tracing::debug;
@@ -54,6 +55,19 @@ pub struct BaseClientBuilder<'a> {
     platform: Option<&'a Platform>,
     auth_integration: AuthIntegration,
     default_timeout: Duration,
+    extra_middleware: Option<ExtraMiddleware>,
+}
+
+/// A list of user-defined middlewares to be applied to the client.
+#[derive(Clone)]
+pub struct ExtraMiddleware(pub Vec<Arc<dyn Middleware>>);
+
+impl Debug for ExtraMiddleware {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ExtraMiddleware")
+            .field("0", &format!("{} middlewares", self.0.len()))
+            .finish()
+    }
 }
 
 impl Default for BaseClientBuilder<'_> {
@@ -75,6 +89,7 @@ impl BaseClientBuilder<'_> {
             platform: None,
             auth_integration: AuthIntegration::default(),
             default_timeout: Duration::from_secs(30),
+            extra_middleware: None,
         }
     }
 }
@@ -140,6 +155,12 @@ impl<'a> BaseClientBuilder<'a> {
         self
     }
 
+    #[must_use]
+    pub fn extra_middleware(mut self, middleware: ExtraMiddleware) -> Self {
+        self.extra_middleware = Some(middleware);
+        self
+    }
+
     pub fn is_offline(&self) -> bool {
         matches!(self.connectivity, Connectivity::Offline)
     }
@@ -313,6 +334,13 @@ impl<'a> BaseClientBuilder<'a> {
                     }
                 }
 
+                // When supplied add the extra middleware
+                if let Some(extra_middleware) = &self.extra_middleware {
+                    for middleware in &extra_middleware.0 {
+                        client = client.with_arc(middleware.clone());
+                    }
+                }
+
                 client.build()
             }
             Connectivity::Offline => reqwest_middleware::ClientBuilder::new(client)

crates/uv-client/src/registry_client.rs

@@ -26,7 +26,7 @@ use uv_pep508::MarkerEnvironment;
 use uv_platform_tags::Platform;
 use uv_pypi_types::{ResolutionMetadata, SimpleJson};
 
-use crate::base_client::BaseClientBuilder;
+use crate::base_client::{BaseClientBuilder, ExtraMiddleware};
 use crate::cached_client::CacheControl;
 use crate::html::SimpleHtml;
 use crate::remote_metadata::wheel_metadata_from_remote_zip;
@@ -110,6 +110,12 @@ impl<'a> RegistryClientBuilder<'a> {
         self
     }
 
+    #[must_use]
+    pub fn extra_middleware(mut self, middleware: ExtraMiddleware) -> Self {
+        self.base_client_builder = self.base_client_builder.extra_middleware(middleware);
+        self
+    }
+
     #[must_use]
     pub fn markers(mut self, markers: &'a MarkerEnvironment) -> Self {
         self.base_client_builder = self.base_client_builder.markers(markers);

crates/uv-dispatch/src/lib.rs

@@ -30,7 +30,7 @@ use uv_pypi_types::Requirement;
 use uv_python::{Interpreter, PythonEnvironment};
 use uv_resolver::{
     ExcludeNewer, FlatIndex, Flexibility, InMemoryIndex, Manifest, OptionsBuilder,
-    PythonRequirement, Resolver, ResolverMarkers,
+    PythonRequirement, Resolver, ResolverEnvironment,
 };
 use uv_types::{BuildContext, BuildIsolation, EmptyInstalledPackages, HashStrategy, InFlight};
 
@@ -174,7 +174,7 @@ 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.resolver_markers();
+        let marker_env = self.interpreter.resolver_marker_environment();
         let tags = self.interpreter.tags()?;
 
         let resolver = Resolver::new(
@@ -185,7 +185,7 @@ impl<'a> BuildContext for BuildDispatch<'a> {
                 .flexibility(Flexibility::Fixed)
                 .build(),
             &python_requirement,
-            ResolverMarkers::specific_environment(markers),
+            ResolverEnvironment::specific(marker_env),
             Some(tags),
             self.flat_index,
             self.index,

crates/uv-normalize/src/extra_name.rs

@@ -23,6 +23,11 @@ impl ExtraName {
     pub fn new(name: String) -> Result<Self, InvalidNameError> {
         validate_and_normalize_owned(name).map(Self)
     }
+
+    /// Return the underlying extra name as a string.
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
 }
 
 impl FromStr for ExtraName {
@@ -51,6 +56,6 @@ impl Display for ExtraName {
 
 impl AsRef<str> for ExtraName {
     fn as_ref(&self) -> &str {
-        &self.0
+        self.as_str()
     }
 }

crates/uv-python/src/discovery.rs

@@ -1546,7 +1546,10 @@ impl PythonPreference {
     }
 
     pub(crate) fn allows_managed(self) -> bool {
-        matches!(self, Self::Managed | Self::OnlyManaged)
+        match self {
+            Self::OnlySystem => false,
+            Self::Managed | Self::System | Self::OnlyManaged => true,
+        }
     }
 }
 

crates/uv-python/src/interpreter.rs

@@ -147,7 +147,7 @@ impl Interpreter {
     }
 
     /// Return the [`ResolverMarkerEnvironment`] for this Python executable.
-    pub fn resolver_markers(&self) -> ResolverMarkerEnvironment {
+    pub fn resolver_marker_environment(&self) -> ResolverMarkerEnvironment {
         ResolverMarkerEnvironment::from(self.markers().clone())
     }
 

crates/uv-requirements/src/lookahead.rs

@@ -10,7 +10,7 @@ use uv_distribution::{DistributionDatabase, Reporter};
 use uv_distribution_types::{Dist, DistributionMetadata};
 use uv_normalize::GroupName;
 use uv_pypi_types::{Requirement, RequirementSource};
-use uv_resolver::{InMemoryIndex, MetadataResponse, ResolverMarkers};
+use uv_resolver::{InMemoryIndex, MetadataResponse, ResolverEnvironment};
 use uv_types::{BuildContext, HashStrategy, RequestedRequirements};
 
 use crate::{required_dist, Error};
@@ -87,7 +87,7 @@ impl<'a, Context: BuildContext> LookaheadResolver<'a, Context> {
     /// to "only evaluate marker expressions that reference an extra name.")
     pub async fn resolve(
         self,
-        markers: &ResolverMarkers,
+        env: &ResolverEnvironment,
     ) -> Result<Vec<RequestedRequirements>, Error> {
         let mut results = Vec::new();
         let mut futures = FuturesUnordered::new();
@@ -97,7 +97,7 @@ impl<'a, Context: BuildContext> LookaheadResolver<'a, Context> {
         let mut queue: VecDeque<_> = self
             .constraints
             .apply(self.overrides.apply(self.requirements))
-            .filter(|requirement| requirement.evaluate_markers(markers.marker_environment(), &[]))
+            .filter(|requirement| requirement.evaluate_markers(env.marker_environment(), &[]))
             .map(|requirement| (*requirement).clone())
             .collect();
 
@@ -117,7 +117,7 @@ impl<'a, Context: BuildContext> LookaheadResolver<'a, Context> {
                         .apply(self.overrides.apply(lookahead.requirements()))
                     {
                         if requirement
-                            .evaluate_markers(markers.marker_environment(), lookahead.extras())
+                            .evaluate_markers(env.marker_environment(), lookahead.extras())
                         {
                             queue.push_back((*requirement).clone());
                         }