feat: refactoring satifisfyability

src/lock_file/package_identifier.rs

@@ -115,7 +115,6 @@ impl PypiPackageIdentifier {
     }
 
     pub fn satisfies(&self, requirement: &Requirement) -> bool {
-        dbg!(&requirement);
         // Verify the name of the package
         if self.name.as_normalized() != &requirement.name {
             return false;

src/lock_file/resolve.rs

@@ -18,11 +18,11 @@ use crate::{
     Project,
 };
 
-use distribution_types::FileLocation;
 use distribution_types::{
     BuiltDist, DirectUrlSourceDist, Dist, IndexLocations, Name, PrioritizedDist, Resolution,
     SourceDist,
 };
+use distribution_types::{DirectUrl, FileLocation};
 use futures::FutureExt;
 use indexmap::IndexMap;
 use indicatif::ProgressBar;
@@ -425,8 +425,36 @@ pub async fn resolve_pypi(
 
                         (url, hash)
                     }
-                    BuiltDist::DirectUrl(dist) => (dist.url.to_url(), None),
-                    BuiltDist::Path(dist) => (dist.url.to_url(), None),
+                    BuiltDist::DirectUrl(dist) => {
+                        // Create the url for the lock file
+                        // if it is a git vcs use the revision hash and
+                        // append this to our given url
+                        let mut url = dist
+                            .url
+                            .given()
+                            .map(|url| Url::parse(url).expect("could not parse given url to path"))
+                            // When using a direct url reference like https://foo/bla.whl we do not have a given
+                            .unwrap_or_else(|| dist.url.to_url());
+                        match DirectUrl::try_from(&dist.url.to_url()) {
+                            Ok(DirectUrl::Git(git_url)) => {
+                                if let Some(sha) = git_url.url.precise() {
+                                    url.set_fragment(Some(&sha.to_string()))
+                                }
+                            }
+                            _ => {}
+                        };
+
+                        (url, None)
+                    }
+                    BuiltDist::Path(dist) => (
+                        dist.url
+                            .given()
+                            .map(|url| {
+                                Url::from_file_path(url).expect("could not parse given url to path")
+                            })
+                            .unwrap_or_else(|| dist.url.to_url()),
+                        None,
+                    ),
                 };
 
                 let metadata = context
@@ -444,6 +472,7 @@ pub async fn resolve_pypi(
                 }
             }
             Dist::Source(source) => {
+                tracing::warn!("{source:?}");
                 let hash = source
                     .file()
                     .and_then(|file| parse_hashes_from_hex(&file.hashes.sha256, &file.hashes.md5));

src/lock_file/satisfiability.rs

@@ -8,7 +8,7 @@ use rattler_conda_types::ParseStrictness::Lenient;
 use rattler_conda_types::{
     GenericVirtualPackage, MatchSpec, ParseMatchSpecError, Platform, RepoDataRecord,
 };
-use rattler_lock::{ConversionError, Package};
+use rattler_lock::{ConversionError, Package, PypiPackageData};
 use std::{
     borrow::Cow,
     collections::{HashMap, HashSet},
@@ -147,6 +147,33 @@ enum Dependency {
     PyPi(Requirement, Cow<'static, str>),
 }
 
+pub fn pypi_satifisfies(locked_data: &PypiPackageData, spec: &Requirement) -> bool {
+    // Check if the name matches
+    if spec.name != locked_data.name {
+        return false;
+    }
+
+    // Check if the version of the requirement matches
+    match &spec.version_or_url {
+        None => true,
+        Some(pep508_rs::VersionOrUrl::Url(spec_url)) => {
+            // Compare the given url with the locked url
+            // by removing the fragment from the locked url
+            // which should essentially remove the `#sha` part
+            let spec_given = spec_url
+                .given()
+                .map(|given| given.to_owned())
+                .unwrap_or_else(|| spec_url.to_url().to_string());
+            let mut locked_given = locked_data.url.clone();
+            locked_given.set_fragment(None);
+            spec_given == locked_given.as_str()
+        }
+        Some(pep508_rs::VersionOrUrl::VersionSpecifier(spec)) => {
+            spec.contains(&locked_data.version)
+        }
+    }
+}
+
 pub fn verify_package_platform_satisfiability(
     environment: &Environment<'_>,
     locked_conda_packages: &RepoDataRecordsByName,
@@ -299,7 +326,7 @@ pub fn verify_package_platform_satisfiability(
                     }
                 } else if let Some(idx) = locked_pypi_environment.index_by_name(&requirement.name) {
                     let record = &locked_pypi_environment.records[idx];
-                    if record.0.satisfies(&requirement) {
+                    if pypi_satifisfies(&record.0, &requirement) {
                         FoundPackage::PyPi(idx, requirement.extras)
                     } else {
                         // The record does not match the spec, the lock-file is inconsistent.

src/project/manifest/python.rs

@@ -1,8 +1,8 @@
 use pep440_rs::VersionSpecifiers;
 use pep508_rs::VerbatimUrl;
 use serde::{de, de::Error, Deserialize, Deserializer, Serialize};
+use std::fmt::Write;
 use std::path::PathBuf;
-use std::process::ExitStatus;
 use std::{fmt, fmt::Formatter, str::FromStr};
 use thiserror::Error;
 use toml_edit::Item;
@@ -392,6 +392,64 @@ fn get_git_branch_hash(
     }
 }
 
+fn create_given_url(
+    url: &Url,
+    branch: Option<&str>,
+    tag: Option<&str>,
+    rev: Option<&str>,
+    subdir: Option<&str>,
+) -> String {
+    // Create the given
+    let mut given = format!("git+{url}");
+    if let Some(branch) = branch {
+        given = format!("{given}?branch={branch}");
+    } else if let Some(tag) = tag {
+        given = format!("{given}?tag={tag}");
+    } else if let Some(rev) = rev {
+        given = format!("{given}?rev={rev}");
+    }
+    if let Some(subdir) = subdir {
+        given = format!("{given}&subdirectory={subdir}");
+    }
+    given
+}
+
+fn create_uv_url(
+    url: &Url,
+    branch: Option<&str>,
+    tag: Option<&str>,
+    rev: Option<&str>,
+    subdir: Option<&str>,
+) -> String {
+    // Check if we need to get the git hash of the branch
+    let branch_hash = if let Some(branch) = branch {
+        // Get the git hash of the branch
+        Some(get_git_branch_hash(url, branch).expect("error getting git branch hash"))
+    } else {
+        None
+    };
+
+    // Choose revision over tag if it is specified
+    let tag_or_rev_or_branch = rev
+        .as_ref()
+        .or_else(|| tag.as_ref())
+        .cloned()
+        .or(branch_hash.as_deref());
+
+    // Create the url.
+    let url = format!("git+{url}");
+    // Add the subdirectory if it exists.
+    let url = subdir.as_ref().map_or_else(
+        || url.clone(),
+        |subdir| format!("{url}#subdirectory={subdir}"),
+    );
+    // Add the tag or rev if it exists.
+    let url = tag_or_rev_or_branch
+        .as_ref()
+        .map_or_else(|| url.clone(), |tag_or_rev| format!("{url}@{tag_or_rev}"));
+    url
+}
+
 impl PyPiRequirement {
     /// Returns the requirements as [`pep508_rs::Requirement`]s.
     pub fn as_pep508(&self, name: &PackageName) -> pep508_rs::Requirement {
@@ -406,33 +464,24 @@ impl PyPiRequirement {
                 rev,
                 subdirectory: subdir,
             } => {
-                // Check if we need to get the git hash of the branch
-                let branch_hash = if let Some(branch) = branch {
-                    // Get the git hash of the branch
-                    Some(get_git_branch_hash(url, branch).expect("error getting git branch hash"))
-                } else {
-                    None
-                };
-                // Choose revision over tag if it is specified
-                let tag_or_rev_or_branch = rev
-                    .as_ref()
-                    .or_else(|| tag.as_ref())
-                    .cloned()
-                    .or(branch_hash);
-
-                // Create the url.
-                let url = format!("git+{url}");
-                // Add the tag or rev if it exists.
-                let url = tag_or_rev_or_branch
-                    .as_ref()
-                    .map_or_else(|| url.clone(), |tag_or_rev| format!("{url}@{tag_or_rev}"));
-                // Add the subdirectory if it exists.
-                let url = subdir.as_ref().map_or_else(
-                    || url.clone(),
-                    |subdir| format!("{url}#subdirectory={subdir}"),
+                let given = create_given_url(
+                    url,
+                    branch.as_deref(),
+                    tag.as_deref(),
+                    rev.as_deref(),
+                    subdir.as_deref(),
+                );
+                let uv_url = create_uv_url(
+                    url,
+                    branch.as_deref(),
+                    tag.as_deref(),
+                    rev.as_deref(),
+                    subdir.as_deref(),
                 );
                 Some(pep508_rs::VersionOrUrl::Url(
-                    VerbatimUrl::parse(&url).expect("git url is invalid"),
+                    VerbatimUrl::parse(uv_url)
+                        .expect("git url is invalid")
+                        .with_given(given),
                 ))
             }
             PyPiRequirementType::Path { path, editable: _ } => {