uv-distribution 0.0.97

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::path::Path;

use uv_cache_info::CacheInfo;
use uv_distribution_filename::WheelFilename;
use uv_distribution_types::{BuildInfo, BuiltDist, CachedDist, Dist, Hashed};
use uv_metadata::{find_flat_dist_info, read_flat_wheel_metadata, read_wheel_variant};
use uv_preview::PreviewFeature;
use uv_pypi_types::{HashDigest, HashDigests, ResolutionMetadata};

use crate::Error;

/// Allow variant wheels from an index when the wheel variants preview is enabled.
pub fn check_supported_wheel_variant(dist: &BuiltDist) -> Result<(), Error> {
    let filename = dist.wheel_filename();
    if filename.variant().is_some()
        && (dist.index().is_none() || !uv_preview::is_enabled(PreviewFeature::WheelVariants))
    {
        return Err(Error::UnsupportedWheelVariant(Box::new(filename.clone())));
    }
    Ok(())
}

/// Whether an extracted wheel's variant properties are supported by the target system.
pub(crate) fn variant_compatible(filename: &WheelFilename, archive: &Path) -> Result<bool, Error> {
    let Some(label) = filename.variant() else {
        return Ok(true);
    };
    if !uv_preview::is_enabled(PreviewFeature::WheelVariants) {
        return Ok(false);
    }

    let dist_info = find_flat_dist_info(filename, archive)
        .map_err(|err| Error::WheelMetadata(archive.to_path_buf(), Box::new(err)))?;
    let path = archive.join(format!("{dist_info}.dist-info/variant.json"));
    let metadata = read_wheel_variant(&path, label)
        .map_err(|err| Error::WheelMetadata(path, Box::new(err)))?;
    Ok(metadata
        .score_variant(label, &metadata.static_supported_properties())
        .is_some())
}

/// A locally available wheel.
#[derive(Debug, Clone)]
pub struct LocalWheel {
    /// The remote distribution from which this wheel was downloaded.
    pub(crate) dist: Dist,
    /// The parsed filename.
    pub(crate) filename: WheelFilename,
    /// The canonicalized path in the cache directory to which the wheel was downloaded.
    /// Typically, a directory within the archive bucket.
    pub(crate) archive: Box<Path>,
    /// The cache info of the wheel.
    pub(crate) cache: CacheInfo,
    /// The build info, if available.
    pub(crate) build: Option<BuildInfo>,
    /// The computed hashes of the wheel.
    pub(crate) hashes: HashDigests,
}

impl LocalWheel {
    /// Return the [`Dist`] from which this wheel was downloaded.
    fn remote(&self) -> &Dist {
        &self.dist
    }

    /// Read the [`ResolutionMetadata`] from a wheel.
    pub(crate) fn metadata(&self) -> Result<ResolutionMetadata, Error> {
        read_flat_wheel_metadata(&self.filename, &self.archive)
            .map_err(|err| Error::WheelMetadata(self.archive.to_path_buf(), Box::new(err)))
    }
}

impl Hashed for LocalWheel {
    fn hashes(&self) -> &[HashDigest] {
        self.hashes.as_slice()
    }
}

/// Convert a [`LocalWheel`] into a [`CachedDist`].
impl From<LocalWheel> for CachedDist {
    fn from(wheel: LocalWheel) -> Self {
        Self::from_remote(
            wheel.dist,
            wheel.filename,
            wheel.hashes,
            wheel.cache,
            wheel.build,
            wheel.archive,
        )
    }
}

impl std::fmt::Display for LocalWheel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.remote())
    }
}