Adds support for pulling packages from PyPI

Cargo.toml

@@ -82,6 +82,7 @@ reqwest = { version = "0.12.26", default-features = false, features = ["gzip", "
 regex = "1.10.6"
 ring = "0.17.14"
 rstest = "0.26.1"
+pep440_rs = "0.7.3"
 serde_plain = "1.0.2"
 serde_with = "3.9.0"
 serde_yaml = "0.9.34"

packages/zpm-primitives/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 colored = { workspace = true }
+pep440_rs = { workspace = true }
 regex = { workspace = true }
 rkyv = { workspace = true, features = ["bytecheck"] }
 serde_plain = { workspace = true }

packages/zpm-primitives/src/descriptor.rs

@@ -91,6 +91,11 @@ impl Descriptor {
                 version: params.version,
             }.into(),
 
+            Reference::PypiRegistry(params) if params.ident == self.ident && params.url.is_none() => reference::PypiShorthandReference {
+                version: params.version,
+                url: None,
+            }.into(),
+
             _ => reference,
         };
 
@@ -259,7 +264,8 @@ impl_file_string_serialization!(Descriptor);
 
 #[rstest]
 #[case("foo@npm:1.0.0")]
-#[case("foo@npm:1.0.0::parent=root@workspace:")]
+#[case("foo@pypi:1.0.0")]
+#[case("foo@npm:1.0.0::parent=root@workspace:.")]
 fn test_descriptor_serialization(#[case] str: &str) {
     assert_eq!(str, Descriptor::from_file_string(str).unwrap().to_file_string());
 }

packages/zpm-primitives/src/lib.rs

@@ -4,6 +4,7 @@ mod descriptor_filter;
 mod descriptor_resolution;
 mod descriptor_semver;
 mod descriptor;
+mod pypi;
 mod range_peer;
 mod range;
 mod reference;
@@ -17,6 +18,7 @@ pub use descriptor_filter::*;
 pub use descriptor_resolution::*;
 pub use descriptor_semver::*;
 pub use descriptor::*;
+pub use pypi::*;
 pub use range_peer::*;
 pub use range::*;
 pub use reference::*;

packages/zpm-primitives/src/locator.rs

@@ -158,7 +158,8 @@ impl_file_string_serialization!(Locator);
 
 #[rstest]
 #[case("foo@npm:1.0.0")]
-#[case("foo@npm:1.0.0::parent=root@workspace:")]
+#[case("foo@pypi:1.0.0")]
+#[case("foo@npm:1.0.0::parent=root@workspace:.")]
 fn test_locator_serialization(#[case] str: &str) {
     assert_eq!(str, Locator::from_file_string(str).unwrap().to_file_string());
 }

packages/zpm-primitives/src/pypi.rs

@@ -0,0 +1,216 @@
+use std::{cmp::Ordering, str::FromStr};
+
+use rkyv::Archive;
+use zpm_semver::VersionRc;
+use zpm_utils::{DataType, EcoVec, FromFileString, ToFileString, ToHumanString, impl_file_string_from_str, impl_file_string_serialization};
+
+#[derive(thiserror::Error, Clone, Debug, PartialEq, Eq)]
+pub enum PypiError {
+    #[error("Invalid PEP 440 version: {0}")]
+    InvalidVersion(String),
+
+    #[error("Invalid PEP 440 specifier set: {0}")]
+    InvalidSpecifier(String),
+
+    #[error("Cannot project PEP 440 version to semver: {0}")]
+    InvalidSemverProjection(String),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Archive, rkyv::Serialize, rkyv::Deserialize)]
+#[rkyv(derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
+pub struct PypiVersion {
+    raw: String,
+}
+
+impl PypiVersion {
+    pub fn as_str(&self) -> &str {
+        &self.raw
+    }
+
+    pub fn is_stable(&self) -> Result<bool, PypiError> {
+        Ok(self.parse()?.is_stable())
+    }
+
+    pub fn cmp_pep440(&self, other: &Self) -> Result<Ordering, PypiError> {
+        Ok(self.parse()?.cmp(&other.parse()?))
+    }
+
+    pub fn satisfies(&self, specifiers: &PypiSpecifierSet) -> Result<bool, PypiError> {
+        specifiers.contains(self)
+    }
+
+    pub fn to_lossy_semver(&self) -> Result<zpm_semver::Version, PypiError> {
+        let parsed = self.parse()?;
+        let release = parsed.release();
+
+        let to_u32 = |n: Option<u64>| -> Result<u32, PypiError> {
+            let n = n.unwrap_or(0);
+            n.try_into().map_err(|_| PypiError::InvalidSemverProjection(self.raw.clone()))
+        };
+
+        let major = to_u32(release.first().copied())?;
+        let minor = to_u32(release.get(1).copied())?;
+        let patch = to_u32(release.get(2).copied())?;
+
+        let mut prerelease_segments = Vec::new();
+
+        if let Some(pre) = parsed.pre() {
+            prerelease_segments.push(pre.kind.to_string());
+            prerelease_segments.push(pre.number.to_string());
+        }
+
+        if let Some(dev) = parsed.dev() {
+            prerelease_segments.push("dev".to_string());
+            prerelease_segments.push(dev.to_string());
+        }
+
+        if let Some(post) = parsed.post() {
+            prerelease_segments.push("post".to_string());
+            prerelease_segments.push(post.to_string());
+        }
+
+        if !parsed.local().is_empty() {
+            prerelease_segments.push("local".to_string());
+
+            for segment in parsed.local() {
+                prerelease_segments.push(segment.to_string().to_ascii_lowercase());
+            }
+        }
+
+        let rc = if prerelease_segments.is_empty() {
+            None
+        } else {
+            let rc_segments = prerelease_segments.into_iter().map(|segment| {
+                match segment.parse::<u32>() {
+                    Ok(number) => VersionRc::Number(number),
+                    Err(_) => VersionRc::String(segment.into()),
+                }
+            }).collect::<Vec<_>>();
+
+            Some(EcoVec::from(rc_segments))
+        };
+
+        Ok(zpm_semver::Version::new_from_components(major, minor, patch, rc))
+    }
+
+    fn parse(&self) -> Result<pep440_rs::Version, PypiError> {
+        pep440_rs::Version::from_str(&self.raw)
+            .map_err(|_| PypiError::InvalidVersion(self.raw.clone()))
+    }
+}
+
+impl FromFileString for PypiVersion {
+    type Error = PypiError;
+
+    fn from_file_string(src: &str) -> Result<Self, Self::Error> {
+        let src = src.trim();
+
+        let parsed = pep440_rs::Version::from_str(src)
+            .map_err(|_| PypiError::InvalidVersion(src.to_string()))?;
+
+        Ok(Self {
+            raw: parsed.to_string(),
+        })
+    }
+}
+
+impl ToFileString for PypiVersion {
+    fn to_file_string(&self) -> String {
+        self.raw.clone()
+    }
+}
+
+impl ToHumanString for PypiVersion {
+    fn to_print_string(&self) -> String {
+        DataType::Reference.colorize(&self.raw)
+    }
+}
+
+impl_file_string_from_str!(PypiVersion);
+impl_file_string_serialization!(PypiVersion);
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Archive, rkyv::Serialize, rkyv::Deserialize)]
+#[rkyv(derive(PartialEq, Eq, PartialOrd, Ord, Hash))]
+pub struct PypiSpecifierSet {
+    raw: String,
+}
+
+impl PypiSpecifierSet {
+    pub fn any() -> Self {
+        Self {
+            raw: "*".to_string(),
+        }
+    }
+
+    pub fn is_any(&self) -> bool {
+        self.raw == "*"
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.raw
+    }
+
+    pub fn contains(&self, version: &PypiVersion) -> Result<bool, PypiError> {
+        if self.is_any() {
+            return Ok(true);
+        }
+
+        let parsed_version = pep440_rs::Version::from_str(version.as_str())
+            .map_err(|_| PypiError::InvalidVersion(version.as_str().to_string()))?;
+
+        if let Ok(specifiers) = pep440_rs::VersionSpecifiers::from_str(&self.raw) {
+            return Ok(specifiers.contains(&parsed_version));
+        }
+
+        let pinned = pep440_rs::Version::from_str(&self.raw)
+            .map_err(|_| PypiError::InvalidSpecifier(self.raw.clone()))?;
+
+        Ok(parsed_version == pinned)
+    }
+}
+
+impl Default for PypiSpecifierSet {
+    fn default() -> Self {
+        Self::any()
+    }
+}
+
+impl FromFileString for PypiSpecifierSet {
+    type Error = PypiError;
+
+    fn from_file_string(src: &str) -> Result<Self, Self::Error> {
+        let src = src.trim();
+
+        if src.is_empty() || src == "*" {
+            return Ok(Self::any());
+        }
+
+        if let Ok(specifiers) = pep440_rs::VersionSpecifiers::from_str(src) {
+            return Ok(Self {
+                raw: specifiers.to_string(),
+            });
+        }
+
+        let version = pep440_rs::Version::from_str(src)
+            .map_err(|_| PypiError::InvalidSpecifier(src.to_string()))?;
+
+        Ok(Self {
+            raw: version.to_string(),
+        })
+    }
+}
+
+impl ToFileString for PypiSpecifierSet {
+    fn to_file_string(&self) -> String {
+        self.raw.clone()
+    }
+}
+
+impl ToHumanString for PypiSpecifierSet {
+    fn to_print_string(&self) -> String {
+        DataType::Range.colorize(&self.raw)
+    }
+}
+
+impl_file_string_from_str!(PypiSpecifierSet);
+impl_file_string_serialization!(PypiSpecifierSet);