feat: Add the ability to skip install of local source dependencies

docs/reference/cli/pixi/install.md

@@ -17,6 +17,9 @@ pixi install [OPTIONS]
 <br>May be provided more than once.
 - <a id="arg---all" href="#arg---all">`--all (-a)`</a>
 :  Install all environments
+- <a id="arg---skip" href="#arg---skip">`--skip <SKIP>`</a>
+:  Skip installation of specific packages present in the lockfile. Requires --frozen. This can be useful for instance in a Dockerfile to skip local source dependencies when installing dependencies
+<br>May be provided more than once.
 
 ## Config Options
 - <a id="arg---auth-file" href="#arg---auth-file">`--auth-file <AUTH_FILE>`</a>

src/cli/install.rs

@@ -2,6 +2,7 @@ use clap::Parser;
 use fancy_display::FancyDisplay;
 use itertools::Itertools;
 use pixi_config::ConfigCli;
+use std::fmt::Write;
 
 use crate::{
     UpdateLockFileOptions, WorkspaceLocator,
@@ -47,6 +48,11 @@ pub struct Args {
     /// Install all environments
     #[arg(long, short, conflicts_with = "environment")]
     pub all: bool,
+
+    /// Skip installation of specific packages present in the lockfile. Requires --frozen.
+    /// This can be useful for instance in a Dockerfile to skip local source dependencies when installing dependencies.
+    #[arg(long, requires = "frozen")]
+    pub skip: Option<Vec<String>>,
 }
 
 pub async fn execute(args: Args) -> miette::Result<()> {
@@ -88,6 +94,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
             max_concurrent_solves: workspace.config().max_concurrent_solves(),
         },
         ReinstallPackages::default(),
+        &args.skip.clone().unwrap_or_default(),
     )
     .await?;
 
@@ -97,28 +104,40 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .collect::<Vec<_>>();
 
     // Message what's installed
-    let detached_envs_message =
-        if let Ok(Some(path)) = workspace.config().detached_environments().path() {
-            format!(" in '{}'", console::style(path.display()).bold())
-        } else {
-            "".to_string()
-        };
+    let mut message = console::style(console::Emoji("✔ ", "")).green().to_string();
 
     if installed_envs.len() == 1 {
-        eprintln!(
-            "{}The {} environment has been installed{}.",
-            console::style(console::Emoji("✔ ", "")).green(),
+        write!(
+            &mut message,
+            "The {} environment has been installed",
             installed_envs[0].fancy_display(),
-            detached_envs_message
-        );
+        )
+        .unwrap();
     } else {
-        eprintln!(
-            "{}The following environments have been installed: {}\t{}",
-            console::style(console::Emoji("✔ ", "")).green(),
+        write!(
+            &mut message,
+            "The following environments have been installed: {}",
             installed_envs.iter().map(|n| n.fancy_display()).join(", "),
-            detached_envs_message
-        );
+        )
+        .unwrap();
+    }
+
+    if let Ok(Some(path)) = workspace.config().detached_environments().path() {
+        write!(
+            &mut message,
+            " in '{}'",
+            console::style(path.display()).bold()
+        )
+        .unwrap()
     }
 
+    if let Some(skip) = args.skip {
+        if !skip.is_empty() {
+            write!(&mut message, " excluding {}", skip.join(", ")).unwrap()
+        }
+    }
+
+    eprintln!("{}.", message);
+
     Ok(())
 }

src/cli/reinstall.rs

@@ -86,6 +86,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
                 max_concurrent_solves: workspace.config().max_concurrent_solves(),
             },
             reinstall_packages.clone(),
+            &[],
         )
         .await?;
 

src/cli/remove.rs

@@ -125,6 +125,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
                 max_concurrent_solves: workspace.config().max_concurrent_solves(),
             },
             ReinstallPackages::default(),
+            &[],
         )
         .await?;
     }

src/cli/run.rs

@@ -261,6 +261,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
                         &executable_task.run_environment,
                         args.prefix_update_config.update_mode(),
                         &ReinstallPackages::default(),
+                        &[],
                     )
                     .await?;
 

src/cli/shell.rs

@@ -288,6 +288,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
             max_concurrent_solves: workspace.config().max_concurrent_solves(),
         },
         ReinstallPackages::default(),
+        &[],
     )
     .await?;
     let lock_file = lock_file_data.into_lock_file();

src/cli/shell_hook.rs

@@ -168,6 +168,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
             max_concurrent_solves: workspace.config().max_concurrent_solves(),
         },
         ReinstallPackages::default(),
+        &[],
     )
     .await?;
 

src/cli/workspace/channel/add.rs

@@ -32,6 +32,7 @@ pub async fn execute(args: AddRemoveArgs) -> miette::Result<()> {
             max_concurrent_solves: workspace.workspace().config().max_concurrent_solves(),
         },
         ReinstallPackages::default(),
+        &[],
     )
     .await?;
 

src/cli/workspace/channel/remove.rs

@@ -30,6 +30,7 @@ pub async fn execute(args: AddRemoveArgs) -> miette::Result<()> {
             max_concurrent_solves: workspace.workspace().config().max_concurrent_solves(),
         },
         ReinstallPackages::default(),
+        &[],
     )
     .await?;
     let workspace = workspace.save().await.into_diagnostic()?;

src/cli/workspace/platform/add.rs

@@ -57,6 +57,7 @@ pub async fn execute(workspace: Workspace, args: Args) -> miette::Result<()> {
             max_concurrent_solves: workspace.workspace().config().max_concurrent_solves(),
         },
         ReinstallPackages::default(),
+        &[],
     )
     .await?;
     workspace.save().await.into_diagnostic()?;

src/cli/workspace/platform/remove.rs

@@ -46,6 +46,7 @@ pub async fn execute(workspace: Workspace, args: Args) -> miette::Result<()> {
             max_concurrent_solves: workspace.workspace().config().max_concurrent_solves(),
         },
         ReinstallPackages::default(),
+        &[],
     )
     .await?;
     workspace.save().await.into_diagnostic()?;

src/environment/mod.rs

@@ -111,11 +111,15 @@ impl LockedEnvironmentHash {
     pub(crate) fn from_environment(
         environment: rattler_lock::Environment,
         platform: Platform,
+        skipped: &[String],
     ) -> Self {
         let mut hasher = Xxh3::new();
 
         if let Some(packages) = environment.packages(platform) {
-            for package in packages {
+            for package in packages
+                // exclude skipped packages
+                .filter(|p| !skipped.iter().any(|s| s == p.name()))
+            {
                 // Always has the url or path
                 package.location().to_owned().to_string().hash(&mut hasher);
 
@@ -418,12 +422,14 @@ pub async fn get_update_lock_file_and_prefix<'env>(
     update_mode: UpdateMode,
     update_lock_file_options: UpdateLockFileOptions,
     reinstall_packages: ReinstallPackages,
+    skipped: &[String],
 ) -> miette::Result<(LockFileDerivedData<'env>, Prefix)> {
     let (lock_file, prefixes) = get_update_lock_file_and_prefixes(
         &[environment.clone()],
         update_mode,
         update_lock_file_options,
         reinstall_packages,
+        skipped,
     )
     .await?;
     Ok((
@@ -442,6 +448,7 @@ pub async fn get_update_lock_file_and_prefixes<'env>(
     update_mode: UpdateMode,
     update_lock_file_options: UpdateLockFileOptions,
     reinstall_packages: ReinstallPackages,
+    skipped: &[String],
 ) -> miette::Result<(LockFileDerivedData<'env>, Vec<Prefix>)> {
     if environments.is_empty() {
         return Err(miette::miette!("No environments provided to install."));
@@ -487,7 +494,7 @@ pub async fn get_update_lock_file_and_prefixes<'env>(
                 std::future::ready(Ok(Prefix::new(env.dir()))).left_future()
             } else {
                 lock_file_ref
-                    .prefix(env, update_mode, reinstall_packages)
+                    .prefix(env, update_mode, reinstall_packages, skipped)
                     .right_future()
             }
         })

src/lib.rs

@@ -7,7 +7,7 @@ pub mod environment;
 mod global;
 mod install_pypi;
 pub mod lock_file;
-mod prefix;
+pub mod prefix;
 mod prompt;
 pub(crate) mod repodata;
 pub mod task;

src/lock_file/update.rs

@@ -305,6 +305,7 @@ impl<'p> LockFileDerivedData<'p> {
     fn locked_environment_hash(
         &self,
         environment: &Environment<'p>,
+        skipped: &[String],
     ) -> miette::Result<LockedEnvironmentHash> {
         let locked_environment = self
             .lock_file
@@ -313,6 +314,7 @@ impl<'p> LockFileDerivedData<'p> {
         Ok(LockedEnvironmentHash::from_environment(
             locked_environment,
             environment.best_platform(),
+            skipped,
         ))
     }
 
@@ -322,18 +324,21 @@ impl<'p> LockFileDerivedData<'p> {
         environment: &Environment<'p>,
         update_mode: UpdateMode,
         reinstall_packages: &ReinstallPackages,
+        skipped: &[String],
     ) -> miette::Result<Prefix> {
         // Check if the prefix is already up-to-date by validating the hash with the
         // environment file
-        let hash = self.locked_environment_hash(environment)?;
+        let hash = self.locked_environment_hash(environment, skipped)?;
         if update_mode == UpdateMode::QuickValidate {
             if let Some(prefix) = self.cached_prefix(environment, &hash) {
                 return prefix;
             }
         }
 
         // Get the up-to-date prefix
-        let prefix = self.update_prefix(environment, reinstall_packages).await?;
+        let prefix = self
+            .update_prefix(environment, reinstall_packages, skipped)
+            .await?;
 
         // Save an environment file to the environment directory after the update.
         // Avoiding writing the cache away before the update is done.
@@ -403,6 +408,7 @@ impl<'p> LockFileDerivedData<'p> {
         &self,
         environment: &Environment<'p>,
         reinstall_packages: &ReinstallPackages,
+        skipped: &[String],
     ) -> miette::Result<Prefix> {
         let prefix_once_cell = self
             .updated_pypi_prefixes
@@ -427,7 +433,7 @@ impl<'p> LockFileDerivedData<'p> {
 
                 let platform = environment.best_platform();
                 let pixi_records = self
-                    .pixi_records(environment, platform)?
+                    .pixi_records(environment, platform, skipped)?
                     .unwrap_or_default();
 
                 let conda_reinstall_packages = match reinstall_packages {
@@ -445,11 +451,11 @@ impl<'p> LockFileDerivedData<'p> {
 
                 // Get the prefix with the conda packages installed.
                 let (prefix, python_status) = self
-                    .conda_prefix(environment, conda_reinstall_packages)
+                    .conda_prefix(environment, conda_reinstall_packages, skipped)
                     .await?;
 
                 let pypi_records = self
-                    .pypi_records(environment, platform)?
+                    .pypi_records(environment, platform, skipped)?
                     .unwrap_or_default();
 
                 // No `uv` support for WASM right now
@@ -553,58 +559,67 @@ impl<'p> LockFileDerivedData<'p> {
             .cloned()
     }
 
+    fn locked_env(
+        &self,
+        environment: &Environment<'p>,
+    ) -> Result<rattler_lock::Environment<'_>, UpdateError> {
+        self.lock_file
+            .environment(environment.name().as_str())
+            .ok_or_else(|| UpdateError::LockFileMissingEnv(environment.name().clone()))
+    }
+
     fn pypi_records(
         &self,
         environment: &Environment<'p>,
         platform: Platform,
+        skipped: &[String],
     ) -> Result<Option<Vec<(PypiPackageData, PypiPackageEnvironmentData)>>, UpdateError> {
-        let locked_env = self
-            .lock_file
-            .environment(environment.name().as_str())
-            .ok_or_else(|| UpdateError::LockFileMissingEnv(environment.name().clone()))?;
-
-        let packages = locked_env.pypi_packages(platform);
-        Ok(packages.map(|iter| {
-            iter.map(|(data, env_data)| (data.clone(), env_data.clone()))
-                .collect()
-        }))
+        match self.locked_env(environment)?.pypi_packages(platform) {
+            Some(packages) => {
+                let records = packages
+                    // exclude skipped packages
+                    .filter(|(p, _)| !skipped.iter().any(|s| s == p.name.as_ref()))
+                    .map(|(data, env_data)| (data.clone(), env_data.clone()))
+                    .collect_vec();
+                Ok(Some(records))
+            }
+            None => Ok(None),
+        }
     }
 
     fn pypi_indexes(
         &self,
         environment: &Environment<'p>,
     ) -> Result<Option<PypiIndexes>, UpdateError> {
-        let locked_env = self
-            .lock_file
-            .environment(environment.name().as_str())
-            .ok_or_else(|| UpdateError::LockFileMissingEnv(environment.name().clone()))?;
-        Ok(locked_env.pypi_indexes().cloned())
+        Ok(self.locked_env(environment)?.pypi_indexes().cloned())
     }
 
     fn pixi_records(
         &self,
         environment: &Environment<'p>,
         platform: Platform,
+        skipped: &[String],
     ) -> Result<Option<Vec<PixiRecord>>, UpdateError> {
-        let locked_env = self
-            .lock_file
-            .environment(environment.name().as_str())
-            .ok_or_else(|| UpdateError::LockFileMissingEnv(environment.name().clone()))?;
-
-        Ok(locked_env
-            .conda_packages(platform)
-            .map(|iter| {
-                iter.cloned()
+        match self.locked_env(environment)?.conda_packages(platform) {
+            Some(packages) => {
+                let records = packages
+                    .cloned()
                     .map(PixiRecord::try_from)
-                    .collect::<Result<Vec<_>, _>>()
-            })
-            .transpose()?)
+                    .collect::<Result<Vec<_>, _>>()?
+                    .into_iter()
+                    .filter(|p| !skipped.iter().any(|s| s == p.name().as_normalized()))
+                    .collect_vec();
+                Ok(Some(records))
+            }
+            None => Ok(None),
+        }
     }
 
     async fn conda_prefix(
         &self,
         environment: &Environment<'p>,
         reinstall_packages: Option<HashSet<PackageName>>,
+        skipped: &[String],
     ) -> miette::Result<(Prefix, PythonStatus)> {
         // If we previously updated this environment, early out.
         let prefix_once_cell = self
@@ -632,7 +647,7 @@ impl<'p> LockFileDerivedData<'p> {
 
                 // Get the locked environment from the lock-file.
                 let records = self
-                    .pixi_records(environment, platform)?
+                    .pixi_records(environment, platform, skipped)?
                     .unwrap_or_default();
                 // Update the conda prefix
                 let CondaPrefixUpdated {