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<()> {
@@ -79,7 +85,7 @@ pub async fn execute(args: Args) -> miette::Result<()> {
         .collect::<Result<Vec<_>, _>>()?;
 
     // Update the prefixes by installing all packages
-    get_update_lock_file_and_prefixes(
+    let (lock_file, _) = get_update_lock_file_and_prefixes(
         &environments,
         UpdateMode::Revalidate,
         UpdateLockFileOptions {
@@ -88,37 +94,68 @@ 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?;
 
     let installed_envs = environments
-        .into_iter()
+        .iter()
         .map(|env| env.name())
         .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 {
+        let mut all_skipped_packages = std::collections::HashSet::new();
+        for env in &environments {
+            let skipped_packages = lock_file.get_skipped_package_names(env, skip)?;
+            all_skipped_packages.extend(skipped_packages);
+        }
+
+        if !all_skipped_packages.is_empty() {
+            let mut skipped_packages_vec: Vec<_> = all_skipped_packages.into_iter().collect();
+            skipped_packages_vec.sort();
+            write!(
+                &mut message,
+                " excluding '{}'",
+                skipped_packages_vec.join("', '")
+            )
+            .unwrap();
+        } else {
+            tracing::warn!(
+                "No packages were skipped. '{}' did not match any packages in the lockfile.",
+                skip.join("', '")
+            );
+        }
+    }
+
+    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

@@ -259,6 +259,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,28 +111,29 @@ 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 {
-                // Always has the url or path
-                package.location().to_owned().to_string().hash(&mut hasher);
-
-                match package {
-                    // A select set of fields are used to hash the package
-                    LockedPackageRef::Conda(pack) => {
-                        if let Some(sha) = pack.record().sha256 {
-                            sha.hash(&mut hasher);
-                        } else if let Some(md5) = pack.record().md5 {
-                            md5.hash(&mut hasher);
-                        }
-                    }
-                    LockedPackageRef::Pypi(pack, env) => {
-                        pack.editable.hash(&mut hasher);
-                        env.extras.hash(&mut hasher);
+        for package in
+            LockFileDerivedData::filter_skipped_packages(environment.packages(platform), skipped)
+        {
+            // Always has the url or path
+            package.location().to_owned().to_string().hash(&mut hasher);
+
+            match package {
+                // A select set of fields are used to hash the package
+                LockedPackageRef::Conda(pack) => {
+                    if let Some(sha) = pack.record().sha256 {
+                        sha.hash(&mut hasher);
+                    } else if let Some(md5) = pack.record().md5 {
+                        md5.hash(&mut hasher);
                     }
                 }
+                LockedPackageRef::Pypi(pack, env) => {
+                    pack.editable.hash(&mut hasher);
+                    env.extras.hash(&mut hasher);
+                }
             }
         }
 
@@ -418,12 +419,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 +445,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 +491,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;