uv-resolver 0.0.87

This is an internal component crate of uv
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use std::sync::Arc;

use rustc_hash::{FxHashMap, FxHashSet};

use uv_distribution_types::{RequirementSource, ResolutionRecorder};
use uv_normalize::PackageName;
use uv_pep440::Version;

use crate::{DependencyMode, Manifest, ResolverEnvironment};

/// A set of package versions that are permitted, even if they're marked as yanked by the
/// relevant index.
#[derive(Debug, Default, Clone)]
pub struct AllowedYanks {
    versions: Arc<FxHashMap<PackageName, FxHashSet<Version>>>,
    recorder: Option<ResolutionRecorder>,
}

impl AllowedYanks {
    pub fn from_manifest(
        manifest: &Manifest,
        env: &ResolverEnvironment,
        dependencies: DependencyMode,
    ) -> Self {
        let mut allowed_yanks = FxHashMap::<PackageName, FxHashSet<Version>>::default();

        // Allow yanks for any pinned input requirements.
        for requirement in manifest.candidate_selection_requirements(env, dependencies) {
            let RequirementSource::Registry { specifier, .. } = &requirement.source else {
                continue;
            };
            let [specifier] = specifier.as_ref() else {
                continue;
            };
            if matches!(
                specifier.operator(),
                uv_pep440::Operator::Equal | uv_pep440::Operator::ExactEqual
            ) {
                allowed_yanks
                    .entry(requirement.name.clone())
                    .or_default()
                    .insert(specifier.version().clone());
            }
        }

        // Allow yanks for any packages that are already pinned in the lockfile.
        for (name, preferences) in manifest.preferences.iter() {
            allowed_yanks
                .entry(name.clone())
                .or_default()
                .extend(preferences.map(|(.., version)| version.clone()));
        }

        Self {
            versions: Arc::new(allowed_yanks),
            recorder: manifest.recorder.clone(),
        }
    }

    /// Returns `true` if the package-version is allowed, even if it's marked as yanked.
    pub(crate) fn contains(&self, package_name: &PackageName, version: &Version) -> bool {
        if let Some(recorder) = &self.recorder {
            recorder.candidate_policy(package_name);
        }
        self.versions
            .get(package_name)
            .is_some_and(|versions| versions.contains(version))
    }
}