Add --dry-run flag to uv pip install

crates/uv/src/commands/mod.rs

@@ -1,5 +1,5 @@
-use std::process::ExitCode;
 use std::time::Duration;
+use std::{fmt::Display, process::ExitCode};
 
 pub(crate) use cache_clean::cache_clean;
 pub(crate) use cache_dir::cache_dir;
@@ -10,6 +10,7 @@ pub(crate) use pip_install::pip_install;
 pub(crate) use pip_list::pip_list;
 pub(crate) use pip_sync::pip_sync;
 pub(crate) use pip_uninstall::pip_uninstall;
+use uv_normalize::PackageName;
 pub(crate) use venv::venv;
 pub(crate) use version::version;
 
@@ -77,6 +78,13 @@ pub(super) struct ChangeEvent<T: InstalledMetadata> {
     kind: ChangeEventKind,
 }
 
+#[derive(Debug)]
+pub(super) struct DryRunEvent<T: Display> {
+    name: PackageName,
+    version: T,
+    kind: ChangeEventKind,
+}
+
 #[derive(Debug, Clone, Copy, clap::ValueEnum)]
 pub(crate) enum VersionFormat {
     Text,

crates/uv/src/commands/pip_install.rs

@@ -1,6 +1,7 @@
 use std::collections::HashSet;
 use std::fmt::Write;
 use std::path::Path;
+use std::time::Instant;
 
 use anstream::eprint;
 use anyhow::{anyhow, Context, Result};
@@ -39,7 +40,7 @@ use crate::commands::{elapsed, ChangeEvent, ChangeEventKind, ExitStatus};
 use crate::printer::Printer;
 use crate::requirements::{ExtrasSpecification, RequirementsSource, RequirementsSpecification};
 
-use super::Upgrade;
+use super::{DryRunEvent, Upgrade};
 
 /// Install packages into the current environment.
 #[allow(clippy::too_many_arguments)]
@@ -66,6 +67,7 @@ pub(crate) async fn pip_install(
     system: bool,
     cache: Cache,
     mut printer: Printer,
+    dry_run: bool,
 ) -> Result<ExitStatus> {
     let start = std::time::Instant::now();
 
@@ -301,6 +303,7 @@ pub(crate) async fn pip_install(
         &cache,
         &venv,
         printer,
+        dry_run,
     )
     .await?;
 
@@ -363,7 +366,7 @@ async fn build_editables(
     build_dispatch: &BuildDispatch<'_>,
     mut printer: Printer,
 ) -> Result<Vec<BuiltEditable>, Error> {
-    let start = std::time::Instant::now();
+    let start = Instant::now();
 
     let downloader = Downloader::new(cache, tags, client, build_dispatch)
         .with_reporter(DownloadReporter::from(printer).with_length(editables.len() as u64));
@@ -514,6 +517,7 @@ async fn install(
     cache: &Cache,
     venv: &PythonEnvironment,
     mut printer: Printer,
+    dry_run: bool,
 ) -> Result<(), Error> {
     let start = std::time::Instant::now();
 
@@ -527,12 +531,7 @@ async fn install(
 
     // Partition into those that should be linked from the cache (`local`), those that need to be
     // downloaded (`remote`), and those that should be removed (`extraneous`).
-    let Plan {
-        local,
-        remote,
-        reinstalls,
-        extraneous: _,
-    } = Planner::with_requirements(&requirements)
+    let plan = Planner::with_requirements(&requirements)
         .with_editable_requirements(&editables)
         .build(
             site_packages,
@@ -545,6 +544,17 @@ async fn install(
         )
         .context("Failed to determine installation plan")?;
 
+    if dry_run {
+        return report_dry_run(resolution, plan, start, printer);
+    }
+
+    let Plan {
+        local,
+        remote,
+        reinstalls,
+        extraneous: _,
+    } = plan;
+
     // Nothing to do.
     if remote.is_empty() && local.is_empty() && reinstalls.is_empty() {
         let s = if resolution.len() == 1 { "" } else { "s" };
@@ -558,7 +568,6 @@ async fn install(
             )
             .dimmed()
         )?;
-
         return Ok(());
     }
 
@@ -577,7 +586,7 @@ async fn install(
     let wheels = if remote.is_empty() {
         vec![]
     } else {
-        let start = std::time::Instant::now();
+        let start = Instant::now();
 
         let downloader = Downloader::new(cache, tags, client, build_dispatch)
             .with_reporter(DownloadReporter::from(printer).with_length(remote.len() as u64));
@@ -679,6 +688,135 @@ async fn install(
         }
     }
 
+    #[allow(clippy::items_after_statements)]
+    fn report_dry_run(
+        resolution: &Resolution,
+        plan: Plan,
+        start: Instant,
+        mut printer: Printer,
+    ) -> Result<(), Error> {
+        let Plan {
+            local,
+            remote,
+            reinstalls,
+            extraneous: _,
+        } = plan;
+
+        // Nothing to do.
+        if remote.is_empty() && local.is_empty() && reinstalls.is_empty() {
+            let s = if resolution.len() == 1 { "" } else { "s" };
+            writeln!(
+                printer,
+                "{}",
+                format!(
+                    "Audited {} in {}",
+                    format!("{} package{}", resolution.len(), s).bold(),
+                    elapsed(start.elapsed())
+                )
+                .dimmed()
+            )?;
+            writeln!(printer, "Would make no changes")?;
+            return Ok(());
+        }
+
+        // Map any registry-based requirements back to those returned by the resolver.
+        let remote = remote
+            .iter()
+            .map(|dist| {
+                resolution
+                    .get(&dist.name)
+                    .cloned()
+                    .expect("Resolution should contain all packages")
+            })
+            .collect::<Vec<_>>();
+
+        // Download, build, and unzip any missing distributions.
+        let wheels = if remote.is_empty() {
+            vec![]
+        } else {
+            let s = if remote.len() == 1 { "" } else { "s" };
+            writeln!(
+                printer,
+                "{}",
+                format!(
+                    "Would download {}",
+                    format!("{} package{}", remote.len(), s).bold(),
+                )
+                .dimmed()
+            )?;
+            remote
+        };
+
+        // Remove any existing installations.
+        if !reinstalls.is_empty() {
+            let s = if reinstalls.len() == 1 { "" } else { "s" };
+            writeln!(
+                printer,
+                "{}",
+                format!(
+                    "Would uninstall {}",
+                    format!("{} package{}", reinstalls.len(), s).bold(),
+                )
+                .dimmed()
+            )?;
+        }
+
+        // Install the resolved distributions.
+        let installs = wheels.len() + local.len();
+
+        if installs > 0 {
+            let s = if installs == 1 { "" } else { "s" };
+            writeln!(
+                printer,
+                "{}",
+                format!("Would install {}", format!("{installs} package{s}").bold(),).dimmed()
+            )?;
+        }
+
+        for event in reinstalls
+            .into_iter()
+            .map(|distribution| DryRunEvent {
+                name: distribution.name().clone(),
+                version: format!("=={}", distribution.version()),
+                kind: ChangeEventKind::Removed,
+            })
+            .chain(wheels.into_iter().map(|distribution| DryRunEvent {
+                name: distribution.name().clone(),
+                version: format!("=={}", distribution.version().unwrap()),
+                kind: ChangeEventKind::Added,
+            }))
+            .chain(local.into_iter().map(|distribution| DryRunEvent {
+                name: distribution.name().clone(),
+                version: distribution.installed_version().to_string(),
+                kind: ChangeEventKind::Added,
+            }))
+            .sorted_unstable_by(|a, b| a.name.cmp(&b.name).then_with(|| a.kind.cmp(&b.kind)))
+        {
+            match event.kind {
+                ChangeEventKind::Added => {
+                    writeln!(
+                        printer,
+                        " {} {}{}",
+                        "+".green(),
+                        event.name.as_ref().bold(),
+                        event.version.dimmed()
+                    )?;
+                }
+                ChangeEventKind::Removed => {
+                    writeln!(
+                        printer,
+                        " {} {}{}",
+                        "-".red(),
+                        event.name.as_ref().bold(),
+                        event.version.dimmed()
+                    )?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     // TODO(konstin): Also check the cache whether any cached or installed dist is already known to
     // have been yanked, we currently don't show this message on the second run anymore
     for dist in &remote {

crates/uv/src/main.rs

@@ -791,6 +791,11 @@ struct PipInstallArgs {
     /// format (e.g., `2006-12-02`).
     #[arg(long, value_parser = date_or_datetime)]
     exclude_newer: Option<DateTime<Utc>>,
+
+    /// Perform a dry run, i.e., don't actually install anything but resolve the dependencies and
+    /// print the resulting plan.
+    #[clap(long)]
+    dry_run: bool,
 }
 
 #[derive(Args)]
@@ -1361,6 +1366,7 @@ async fn run() -> Result<ExitStatus> {
                 args.system,
                 cache,
                 printer,
+                args.dry_run,
             )
             .await
         }