feat: editable pypi packages (#581)

Adds the `editable` field to pypi packages to indicate they are
installed in editable mode.

Author: baszalmstra

crates/rattler_lock/src/lib.rs

@@ -89,7 +89,7 @@ pub use channel::Channel;
 pub use conda::{CondaPackageData, ConversionError};
 pub use hash::PackageHashes;
 pub use parse::ParseCondaLockError;
-pub use pypi::{PypiPackageData, PypiPackageEnvironmentData};
+pub use pypi::{PypiPackageData, PypiPackageEnvironmentData, PypiSourceTreeHashable};
 pub use url_or_path::UrlOrPath;
 
 /// The name of the default environment in a [`LockFile`]. This is the environment name that is used
@@ -560,6 +560,11 @@ impl PypiPackage {
     pub fn satisfies(&self, spec: &Requirement) -> bool {
         self.package_data().satisfies(spec)
     }
+
+    /// Returns true if this package should be installed in "editable" mode.
+    pub fn is_editable(&self) -> bool {
+        self.package_data().editable
+    }
 }
 
 /// A helper struct to group package and environment data together.

crates/rattler_lock/src/parse/v3.rs

@@ -185,6 +185,7 @@ pub fn parse_v3_or_lower(document: serde_yaml::Value) -> Result<LockFile, ParseC
                         requires_python: pkg.requires_python,
                         url_or_path: UrlOrPath::Url(pkg.url),
                         hash: pkg.hash,
+                        editable: false,
                     })
                     .0;
                 EnvironmentPackageData::Pypi(

crates/rattler_lock/src/pypi.rs

@@ -1,10 +1,13 @@
 use crate::{PackageHashes, UrlOrPath};
 use pep440_rs::VersionSpecifiers;
 use pep508_rs::{ExtraName, PackageName, Requirement};
+use rattler_digest::{digest::Digest, Sha256};
 use serde::{Deserialize, Serialize};
 use serde_with::{serde_as, skip_serializing_none};
 use std::cmp::Ordering;
 use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
 
 /// A pinned Pypi package
 #[serde_as]
@@ -31,6 +34,10 @@ pub struct PypiPackageData {
 
     /// The python version that this package requires.
     pub requires_python: Option<VersionSpecifiers>,
+
+    /// Whether the projects should be installed in editable mode or not.
+    #[serde(default, skip_serializing_if = "should_skip_serializing_editable")]
+    pub editable: bool,
 }
 
 /// Additional runtime configuration of a package. Multiple environments/platforms might refer to
@@ -77,3 +84,73 @@ impl PypiPackageData {
         true
     }
 }
+
+/// Used in `skip_serializing_if` to skip serializing the `editable` field if it is `false`.
+fn should_skip_serializing_editable(editable: &bool) -> bool {
+    !*editable
+}
+
+/// A struct that wraps the hashable part of a source package.
+///
+/// This struct the relevant parts of a source package that are used to compute a [`PackageHashes`].
+pub struct PypiSourceTreeHashable {
+    /// The contents of an optional pyproject.toml file.
+    pub pyproject_toml: Option<String>,
+
+    /// The contents of an optional setup.py file.
+    pub setup_py: Option<String>,
+
+    /// The contents of an optional setup.cfg file.
+    pub setup_cfg: Option<String>,
+}
+
+fn ignore_not_found<C>(result: std::io::Result<C>) -> std::io::Result<Option<C>> {
+    match result {
+        Ok(content) => Ok(Some(content)),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(err) => Err(err),
+    }
+}
+
+/// Ensure that line endings are normalized to `\n` this ensures that if files are checked out on
+/// windows through git they still have the same hash as on linux.
+fn normalize_file_contents(contents: &str) -> String {
+    contents.replace("\r\n", "\n")
+}
+
+impl PypiSourceTreeHashable {
+    /// Creates a new [`PypiSourceTreeHashable`] from a directory containing a source package.
+    pub fn from_directory(directory: impl AsRef<Path>) -> std::io::Result<Self> {
+        let directory = directory.as_ref();
+
+        let pyproject_toml =
+            ignore_not_found(fs::read_to_string(directory.join("pyproject.toml")))?;
+        let setup_py = ignore_not_found(fs::read_to_string(directory.join("setup.py")))?;
+        let setup_cfg = ignore_not_found(fs::read_to_string(directory.join("setup.cfg")))?;
+
+        Ok(Self {
+            pyproject_toml: pyproject_toml.as_deref().map(normalize_file_contents),
+            setup_py: setup_py.as_deref().map(normalize_file_contents),
+            setup_cfg: setup_cfg.as_deref().map(normalize_file_contents),
+        })
+    }
+
+    /// Determine the [`PackageHashes`] of this source package.
+    pub fn hash(&self) -> PackageHashes {
+        let mut hasher = Sha256::new();
+
+        if let Some(pyproject_toml) = &self.pyproject_toml {
+            hasher.update(pyproject_toml.as_bytes());
+        }
+
+        if let Some(setup_py) = &self.setup_py {
+            hasher.update(setup_py.as_bytes());
+        }
+
+        if let Some(setup_cfg) = &self.setup_cfg {
+            hasher.update(setup_cfg.as_bytes());
+        }
+
+        PackageHashes::Sha256(hasher.finalize())
+    }
+}

crates/rattler_lock/src/snapshots/rattler_lock__test__v4__path-based-lock.yml.snap

@@ -1,6 +1,6 @@
 ---
 source: crates/rattler_lock/src/lib.rs
-assertion_line: 597
+assertion_line: 602
 expression: conda_lock
 ---
 version: 4
@@ -251,6 +251,7 @@ packages:
     name: minimal-project
     version: "0.1"
     path: "./minimal_project"
+    editable: true
   - kind: conda
     name: openssl
     version: 3.2.1

py-rattler/rattler/lock/pypi.py

@@ -151,6 +151,26 @@ def requires_python(self) -> Optional[str]:
         """
         return self._data.requires_python
 
+    @property
+    def is_editable(self) -> bool:
+        """
+        Whether the package should be installed in editable mode or not.
+
+        Examples
+        --------
+        ```python
+        >>> from rattler import LockFile, Platform
+        >>> lock_file = LockFile.from_path("../test-data/test.lock")
+        >>> env = lock_file.default_environment()
+        >>> pypi_packages = env.pypi_packages()
+        >>> data = pypi_packages[Platform("osx-arm64")][0][0]
+        >>> data.is_editable
+        False
+        >>>
+        ```
+        """
+        return self._data.is_editable
+
     @classmethod
     def _from_py_pypi_package_data(cls, pkg_data: PyPypiPackageData) -> PypiPackageData:
         """

py-rattler/src/lock/mod.rs

@@ -422,6 +422,12 @@ impl PyPypiPackageData {
         self.inner.url_or_path.to_string()
     }
 
+    /// Whether the package is installed in editable mode or not.
+    #[getter]
+    pub fn is_editable(&self) -> bool {
+        self.inner.editable
+    }
+
     /// Hashes of the file pointed to by `url`.
     #[getter]
     pub fn hash(&self) -> Option<PyPackageHashes> {

test-data/conda-lock/v4/path-based-lock.yml

@@ -246,6 +246,7 @@ packages:
   name: minimal-project
   version: '0.1'
   path: ./minimal_project
+  editable: true
 - kind: conda
   name: openssl
   version: 3.2.1