Fix schema

Author: charliermarsh

crates/uv-cli/src/lib.rs

@@ -14,7 +14,7 @@ use uv_configuration::{
     ConfigSettingEntry, ExportFormat, IndexStrategy, KeyringProviderType, PackageNameSpecifier,
     TargetTriple, TrustedHost, TrustedPublishing, VersionControlSystem,
 };
-use uv_distribution_types::{Index, IndexUrl, Origin};
+use uv_distribution_types::{Index, IndexUrl, Origin, PipExtraIndex, PipFindLinks, PipIndex};
 use uv_normalize::{ExtraName, PackageName};
 use uv_pep508::Requirement;
 use uv_pypi_types::VerbatimParsedUrl;
@@ -772,48 +772,54 @@ impl<T> Maybe<T> {
     }
 }
 
-/// Parse an `--index-url` argument into an [`Index`], mapping the empty string to `None`.
-fn parse_index_url(input: &str) -> Result<Maybe<Index>, String> {
+/// Parse an `--index-url` argument into an [`PipIndex`], mapping the empty string to `None`.
+fn parse_index_url(input: &str) -> Result<Maybe<PipIndex>, String> {
     if input.is_empty() {
         Ok(Maybe::None)
     } else {
-        match IndexUrl::from_str(input).map(Index::from_index_url) {
-            Ok(index) => Ok(Maybe::Some(Index {
+        IndexUrl::from_str(input)
+            .map(Index::from_index_url)
+            .map(|index| Index {
                 origin: Some(Origin::Cli),
                 ..index
-            })),
-            Err(err) => Err(err.to_string()),
-        }
+            })
+            .map(PipIndex::from)
+            .map(Maybe::Some)
+            .map_err(|err| err.to_string())
     }
 }
 
-/// Parse an `--extra-index-url` argument into an [`Index`], mapping the empty string to `None`.
-fn parse_extra_index_url(input: &str) -> Result<Maybe<Index>, String> {
+/// Parse an `--extra-index-url` argument into an [`PipExtraIndex`], mapping the empty string to `None`.
+fn parse_extra_index_url(input: &str) -> Result<Maybe<PipExtraIndex>, String> {
     if input.is_empty() {
         Ok(Maybe::None)
     } else {
-        match IndexUrl::from_str(input).map(Index::from_extra_index_url) {
-            Ok(index) => Ok(Maybe::Some(Index {
+        IndexUrl::from_str(input)
+            .map(Index::from_extra_index_url)
+            .map(|index| Index {
                 origin: Some(Origin::Cli),
                 ..index
-            })),
-            Err(err) => Err(err.to_string()),
-        }
+            })
+            .map(PipExtraIndex::from)
+            .map(Maybe::Some)
+            .map_err(|err| err.to_string())
     }
 }
 
-/// Parse a `--find-links` argument into an [`Index`], mapping the empty string to `None`.
-fn parse_find_links(input: &str) -> Result<Maybe<Index>, String> {
+/// Parse a `--find-links` argument into an [`PipFindLinks`], mapping the empty string to `None`.
+fn parse_find_links(input: &str) -> Result<Maybe<PipFindLinks>, String> {
     if input.is_empty() {
         Ok(Maybe::None)
     } else {
-        match IndexUrl::from_str(input).map(Index::from_find_links) {
-            Ok(index) => Ok(Maybe::Some(Index {
+        IndexUrl::from_str(input)
+            .map(Index::from_find_links)
+            .map(|index| Index {
                 origin: Some(Origin::Cli),
                 ..index
-            })),
-            Err(err) => Err(err.to_string()),
-        }
+            })
+            .map(PipFindLinks::from)
+            .map(Maybe::Some)
+            .map_err(|err| err.to_string())
     }
 }
 
@@ -3800,7 +3806,7 @@ pub struct IndexArgs {
     /// The index given by this flag is given lower priority than all other
     /// indexes specified via the `--extra-index-url` flag.
     #[arg(long, short, env = "UV_INDEX_URL", value_parser = parse_index_url, help_heading = "Index options")]
-    pub index_url: Option<Maybe<Index>>,
+    pub index_url: Option<Maybe<PipIndex>>,
 
     /// (Deprecated: use `--index` instead) Extra URLs of package indexes to use, in addition to `--index-url`.
     ///
@@ -3811,7 +3817,7 @@ pub struct IndexArgs {
     /// `--index-url` (which defaults to PyPI). When multiple `--extra-index-url` flags are
     /// provided, earlier values take priority.
     #[arg(long, env = "UV_EXTRA_INDEX_URL", value_delimiter = ' ', value_parser = parse_extra_index_url, help_heading = "Index options")]
-    pub extra_index_url: Option<Vec<Maybe<Index>>>,
+    pub extra_index_url: Option<Vec<Maybe<PipExtraIndex>>>,
 
     /// Locations to search for candidate distributions, in addition to those found in the registry
     /// indexes.
@@ -3822,7 +3828,7 @@ pub struct IndexArgs {
     /// If a URL, the page must contain a flat list of links to package files adhering to the
     /// formats described above.
     #[arg(long, short, value_parser = parse_find_links, help_heading = "Index options")]
-    pub find_links: Option<Vec<Maybe<Index>>>,
+    pub find_links: Option<Vec<Maybe<PipFindLinks>>>,
 
     /// Ignore the registry index (e.g., PyPI), instead relying on direct URL dependencies and those
     /// provided via `--find-links`.

crates/uv-cli/src/options.rs

@@ -1,5 +1,6 @@
 use uv_cache::Refresh;
 use uv_configuration::ConfigSettings;
+use uv_distribution_types::{PipExtraIndex, PipFindLinks, PipIndex};
 use uv_resolver::PrereleaseMode;
 use uv_settings::{Combine, PipOptions, ResolverInstallerOptions, ResolverOptions};
 
@@ -201,18 +202,20 @@ impl From<IndexArgs> for PipOptions {
                 .combine(
                     index.map(|index| index.into_iter().filter_map(Maybe::into_option).collect()),
                 ),
-            index_url: index_url.and_then(Maybe::into_option),
+            index_url: index_url.and_then(Maybe::into_option).map(PipIndex::from),
             extra_index_url: extra_index_url.map(|extra_index_urls| {
                 extra_index_urls
                     .into_iter()
                     .filter_map(Maybe::into_option)
+                    .map(PipExtraIndex::from)
                     .collect()
             }),
             no_index: if no_index { Some(true) } else { None },
             find_links: find_links.map(|find_links| {
                 find_links
                     .into_iter()
                     .filter_map(Maybe::into_option)
+                    .map(PipFindLinks::from)
                     .collect()
             }),
             ..PipOptions::default()

crates/uv-dispatch/src/lib.rs

@@ -156,7 +156,7 @@ impl<'a> BuildContext for BuildDispatch<'a> {
         self.sources
     }
 
-    fn index_locations(&self) -> &IndexLocations {
+    fn locations(&self) -> &IndexLocations {
         self.index_locations
     }
 

crates/uv-distribution-types/src/index.rs

@@ -1,5 +1,4 @@
 use std::str::FromStr;
-
 use thiserror::Error;
 use url::Url;
 use uv_auth::Credentials;
@@ -113,6 +112,7 @@ impl Index {
         }
     }
 
+    /// Set the [`Origin`] of the index.
     #[must_use]
     pub fn with_origin(mut self, origin: Origin) -> Self {
         self.origin = Some(origin);

crates/uv-distribution-types/src/lib.rs

@@ -61,6 +61,7 @@ pub use crate::index::*;
 pub use crate::index_url::*;
 pub use crate::installed::*;
 pub use crate::origin::*;
+pub use crate::pip_index::*;
 pub use crate::prioritized_distribution::*;
 pub use crate::resolution::*;
 pub use crate::resolved::*;
@@ -81,6 +82,7 @@ mod index;
 mod index_url;
 mod installed;
 mod origin;
+mod pip_index;
 mod prioritized_distribution;
 mod resolution;
 mod resolved;

crates/uv-distribution-types/src/pip_index.rs

@@ -0,0 +1,59 @@
+//! Compatibility structs for converting between [`IndexUrl`] and [`Index`]. These structs are
+//! parsed and deserialized as [`IndexUrl`], but are stored as [`Index`] with the appropriate
+//! flags set.
+
+use serde::{Deserialize, Deserializer, Serialize};
+
+use crate::{Index, IndexUrl};
+
+macro_rules! impl_index {
+    ($name:ident, $from:expr) => {
+        #[derive(Debug, Clone, Eq, PartialEq)]
+        pub struct $name(Index);
+
+        impl From<$name> for Index {
+            fn from(value: $name) -> Self {
+                value.0
+            }
+        }
+
+        impl From<Index> for $name {
+            fn from(value: Index) -> Self {
+                Self(value)
+            }
+        }
+
+        impl Serialize for $name {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: serde::Serializer,
+            {
+                self.0.url().serialize(serializer)
+            }
+        }
+
+        impl<'de> Deserialize<'de> for $name {
+            fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                IndexUrl::deserialize(deserializer).map($from).map(Self)
+            }
+        }
+
+        #[cfg(feature = "schemars")]
+        impl schemars::JsonSchema for $name {
+            fn schema_name() -> String {
+                IndexUrl::schema_name()
+            }
+
+            fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+                IndexUrl::json_schema(gen)
+            }
+        }
+    };
+}
+
+impl_index!(PipIndex, Index::from_index_url);
+impl_index!(PipExtraIndex, Index::from_extra_index_url);
+impl_index!(PipFindLinks, Index::from_find_links);

crates/uv-distribution/src/metadata/lowering.rs

@@ -6,7 +6,7 @@ use thiserror::Error;
 use url::Url;
 
 use uv_distribution_filename::DistExtension;
-use uv_distribution_types::Index;
+use uv_distribution_types::{Index, IndexLocations, Origin};
 use uv_git::GitReference;
 use uv_normalize::PackageName;
 use uv_pep440::VersionSpecifiers;
@@ -20,7 +20,7 @@ use uv_workspace::Workspace;
 pub struct LoweredRequirement(Requirement);
 
 #[derive(Debug, Clone, Copy)]
-enum Origin {
+enum RequirementOrigin {
     /// The `tool.uv.sources` were read from the project.
     Project,
     /// The `tool.uv.sources` were read from the workspace root.
@@ -35,14 +35,15 @@ impl LoweredRequirement {
         project_dir: &'data Path,
         project_sources: &'data BTreeMap<PackageName, Sources>,
         project_indexes: &'data [Index],
+        locations: &'data IndexLocations,
         workspace: &'data Workspace,
-    ) -> impl Iterator<Item = Result<LoweredRequirement, LoweringError>> + 'data {
+    ) -> impl Iterator<Item = Result<Self, LoweringError>> + 'data {
         let (source, origin) = if let Some(source) = project_sources.get(&requirement.name) {
-            (Some(source), Origin::Project)
+            (Some(source), RequirementOrigin::Project)
         } else if let Some(source) = workspace.sources().get(&requirement.name) {
-            (Some(source), Origin::Workspace)
+            (Some(source), RequirementOrigin::Workspace)
         } else {
-            (None, Origin::Project)
+            (None, RequirementOrigin::Project)
         };
         let source = source.cloned();
 
@@ -152,16 +153,14 @@ impl LoweredRequirement {
                         Source::Registry { index, marker } => {
                             // Identify the named index from either the project indexes or the workspace indexes,
                             // in that order.
-                            let Some(index) = project_indexes
-                                .iter()
+                            let Some(index) = locations
+                                .indexes()
+                                .filter(|index| matches!(index.origin, Some(Origin::Cli)))
+                                .chain(project_indexes.iter())
+                                .chain(workspace.indexes().iter())
                                 .find(|Index { name, .. }| {
                                     name.as_ref().is_some_and(|name| *name == index)
                                 })
-                                .or_else(|| {
-                                    workspace.indexes().iter().find(|Index { name, .. }| {
-                                        name.as_ref().is_some_and(|name| *name == index)
-                                    })
-                                })
                                 .map(|Index { url: index, .. }| index.clone())
                             else {
                                 return Err(LoweringError::MissingIndex(
@@ -257,7 +256,8 @@ impl LoweredRequirement {
         dir: &'data Path,
         sources: &'data BTreeMap<PackageName, Sources>,
         indexes: &'data [Index],
-    ) -> impl Iterator<Item = Result<LoweredRequirement, LoweringError>> + 'data {
+        locations: &'data IndexLocations,
+    ) -> impl Iterator<Item = Result<Self, LoweringError>> + 'data {
         let source = sources.get(&requirement.name).cloned();
 
         let Some(source) = source else {
@@ -329,16 +329,18 @@ impl LoweredRequirement {
                             }
                             let source = path_source(
                                 PathBuf::from(path),
-                                Origin::Project,
+                                RequirementOrigin::Project,
                                 dir,
                                 dir,
                                 editable.unwrap_or(false),
                             )?;
                             (source, marker)
                         }
                         Source::Registry { index, marker } => {
-                            let Some(index) = indexes
-                                .iter()
+                            let Some(index) = locations
+                                .indexes()
+                                .filter(|index| matches!(index.origin, Some(Origin::Cli)))
+                                .chain(indexes.iter())
                                 .find(|Index { name, .. }| {
                                     name.as_ref().is_some_and(|name| *name == index)
                                 })
@@ -505,15 +507,15 @@ fn registry_source(
 /// Convert a path string to a file or directory source.
 fn path_source(
     path: impl AsRef<Path>,
-    origin: Origin,
+    origin: RequirementOrigin,
     project_dir: &Path,
     workspace_root: &Path,
     editable: bool,
 ) -> Result<RequirementSource, LoweringError> {
     let path = path.as_ref();
     let base = match origin {
-        Origin::Project => project_dir,
-        Origin::Workspace => workspace_root,
+        RequirementOrigin::Project => project_dir,
+        RequirementOrigin::Workspace => workspace_root,
     };
     let url = VerbatimUrl::from_path(path, base)?.with_given(path.to_string_lossy());
     let install_path = url.to_file_path().map_err(|()| {

crates/uv-distribution/src/metadata/mod.rs

@@ -4,6 +4,7 @@ use std::path::Path;
 use thiserror::Error;
 
 use uv_configuration::SourceStrategy;
+use uv_distribution_types::IndexLocations;
 use uv_normalize::{ExtraName, GroupName, PackageName};
 use uv_pep440::{Version, VersionSpecifiers};
 use uv_pypi_types::{HashDigest, ResolutionMetadata};
@@ -61,6 +62,7 @@ impl Metadata {
     pub async fn from_workspace(
         metadata: ResolutionMetadata,
         install_path: &Path,
+        locations: &IndexLocations,
         sources: SourceStrategy,
     ) -> Result<Self, MetadataError> {
         // Lower the requirements.
@@ -76,6 +78,7 @@ impl Metadata {
                 provides_extras: metadata.provides_extras,
             },
             install_path,
+            locations,
             sources,
         )
         .await?;