Add support for --upgrade-group

crates/uv-cli/src/lib.rs

@@ -5717,8 +5717,9 @@ pub struct ToolUpgradeArgs {
     #[arg(long)]
     pub python_platform: Option<TargetTriple>,
 
-    // The following is equivalent to flattening `ResolverInstallerArgs`, with the `--upgrade`, and
-    // `--upgrade-package` options hidden, and the `--no-upgrade` option removed.
+    // The following is equivalent to flattening `ResolverInstallerArgs`, with the `--upgrade`,
+    // `--upgrade-package`, and `--upgrade-group` options hidden, and the `--no-upgrade` option
+    // removed.
     /// Allow package upgrades, ignoring pinned versions in any existing output file. Implies
     /// `--refresh`.
     #[arg(hide = true, long, short = 'U', help_heading = "Resolver options")]
@@ -5729,6 +5730,11 @@ pub struct ToolUpgradeArgs {
     #[arg(hide = true, long, short = 'P', help_heading = "Resolver options")]
     pub upgrade_package: Vec<Requirement<VerbatimParsedUrl>>,
 
+    /// Allow upgrades for all packages in a dependency group, ignoring pinned versions in any
+    /// existing output file.
+    #[arg(hide = true, long, help_heading = "Resolver options")]
+    pub upgrade_group: Vec<GroupName>,
+
     #[command(flatten)]
     pub index_args: IndexArgs,
 
@@ -7048,6 +7054,11 @@ pub struct ResolverArgs {
     #[arg(long, short = 'P', help_heading = "Resolver options")]
     pub upgrade_package: Vec<Requirement<VerbatimParsedUrl>>,
 
+    /// Allow upgrades for all packages in a dependency group, ignoring pinned versions in any
+    /// existing output file.
+    #[arg(long, help_heading = "Resolver options")]
+    pub upgrade_group: Vec<GroupName>,
+
     /// The strategy to use when resolving against multiple index URLs.
     ///
     /// By default, uv will stop at the first index on which a given package is available, and limit
@@ -7259,6 +7270,11 @@ pub struct ResolverInstallerArgs {
     #[arg(long, short = 'P', help_heading = "Resolver options", value_hint = ValueHint::Other)]
     pub upgrade_package: Vec<Requirement<VerbatimParsedUrl>>,
 
+    /// Allow upgrades for all packages in a dependency group, ignoring pinned versions in any
+    /// existing output file.
+    #[arg(long, help_heading = "Resolver options")]
+    pub upgrade_group: Vec<GroupName>,
+
     /// Reinstall all packages, regardless of whether they're already installed. Implies
     /// `--refresh`.
     #[arg(

crates/uv-cli/src/options.rs

@@ -202,6 +202,7 @@ impl From<ResolverArgs> for PipOptions {
             upgrade,
             no_upgrade,
             upgrade_package,
+            upgrade_group,
             index_strategy,
             keyring_provider,
             resolution,
@@ -220,6 +221,16 @@ impl From<ResolverArgs> for PipOptions {
             exclude_newer_package,
         } = args;
 
+        if !upgrade_group.is_empty() {
+            eprintln!(
+                "{}{} `{}` is not supported in `uv pip` commands",
+                "error".bold().red(),
+                ":".bold(),
+                "--upgrade-group".green(),
+            );
+            std::process::exit(2);
+        }
+
         Self {
             upgrade: flag(upgrade, no_upgrade, "no-upgrade"),
             upgrade_package: Some(upgrade_package),
@@ -304,6 +315,7 @@ impl From<ResolverInstallerArgs> for PipOptions {
             upgrade,
             no_upgrade,
             upgrade_package,
+            upgrade_group,
             reinstall,
             no_reinstall,
             reinstall_package,
@@ -327,6 +339,16 @@ impl From<ResolverInstallerArgs> for PipOptions {
             exclude_newer_package,
         } = args;
 
+        if !upgrade_group.is_empty() {
+            eprintln!(
+                "{}{} `{}` is not supported in `uv pip` commands",
+                "error".bold().red(),
+                ":".bold(),
+                "--upgrade-group".green(),
+            );
+            std::process::exit(2);
+        }
+
         Self {
             upgrade: flag(upgrade, no_upgrade, "upgrade"),
             upgrade_package: Some(upgrade_package),
@@ -430,6 +452,7 @@ pub fn resolver_options(
         upgrade,
         no_upgrade,
         upgrade_package,
+        upgrade_group,
         index_strategy,
         keyring_provider,
         resolution,
@@ -490,6 +513,7 @@ pub fn resolver_options(
         upgrade: Upgrade::from_args(
             flag(upgrade, no_upgrade, "no-upgrade"),
             upgrade_package.into_iter().map(Requirement::from).collect(),
+            upgrade_group,
         ),
         index_strategy,
         keyring_provider,
@@ -539,6 +563,7 @@ pub fn resolver_installer_options(
         upgrade,
         no_upgrade,
         upgrade_package,
+        upgrade_group,
         reinstall,
         no_reinstall,
         reinstall_package,
@@ -606,6 +631,7 @@ pub fn resolver_installer_options(
         upgrade: Upgrade::from_args(
             flag(upgrade, no_upgrade, "upgrade"),
             upgrade_package.into_iter().map(Requirement::from).collect(),
+            upgrade_group,
         ),
         reinstall: Reinstall::from_args(
             flag(reinstall, no_reinstall, "reinstall"),

crates/uv-configuration/src/package_options.rs

@@ -5,7 +5,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use uv_cache::Refresh;
 use uv_cache_info::Timestamp;
 use uv_distribution_types::{Requirement, RequirementSource};
-use uv_normalize::PackageName;
+use uv_normalize::{GroupName, PackageName};
 
 /// Whether to reinstall packages.
 #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
@@ -153,6 +153,9 @@ pub struct Upgrade {
 
     /// Additional version constraints for specific packages.
     constraints: FxHashMap<PackageName, Vec<Requirement>>,
+
+    /// Dependency groups whose packages should be upgraded.
+    groups: FxHashSet<GroupName>,
 }
 
 impl Upgrade {
@@ -161,6 +164,7 @@ impl Upgrade {
         Self {
             strategy: UpgradeStrategy::None,
             constraints: FxHashMap::default(),
+            groups: FxHashSet::default(),
         }
     }
 
@@ -169,23 +173,30 @@ impl Upgrade {
         Self {
             strategy: UpgradeStrategy::All,
             constraints: FxHashMap::default(),
+            groups: FxHashSet::default(),
         }
     }
 
     /// Determine the upgrade selection strategy from the command-line arguments.
-    pub fn from_args(upgrade: Option<bool>, upgrade_package: Vec<Requirement>) -> Option<Self> {
+    pub fn from_args(
+        upgrade: Option<bool>,
+        upgrade_package: Vec<Requirement>,
+        upgrade_group: Vec<GroupName>,
+    ) -> Option<Self> {
+        let groups: FxHashSet<GroupName> = upgrade_group.into_iter().collect();
+
         let strategy = match upgrade {
             Some(true) => UpgradeStrategy::All,
             Some(false) => {
-                if upgrade_package.is_empty() {
+                if upgrade_package.is_empty() && groups.is_empty() {
                     return Some(Self::none());
                 }
                 // `--no-upgrade` with `--upgrade-package` allows selecting the specified packages for upgrade.
                 let packages = upgrade_package.iter().map(|req| req.name.clone()).collect();
                 UpgradeStrategy::Packages(packages)
             }
             None => {
-                if upgrade_package.is_empty() {
+                if upgrade_package.is_empty() && groups.is_empty() {
                     return None;
                 }
                 let packages = upgrade_package.iter().map(|req| req.name.clone()).collect();
@@ -210,6 +221,7 @@ impl Upgrade {
         Some(Self {
             strategy,
             constraints,
+            groups,
         })
     }
 
@@ -220,12 +232,13 @@ impl Upgrade {
         Self {
             strategy: UpgradeStrategy::Packages(packages),
             constraints: FxHashMap::default(),
+            groups: FxHashSet::default(),
         }
     }
 
     /// Returns `true` if no packages should be upgraded.
     pub fn is_none(&self) -> bool {
-        matches!(self.strategy, UpgradeStrategy::None)
+        matches!(self.strategy, UpgradeStrategy::None) && self.groups.is_empty()
     }
 
     /// Returns `true` if all packages should be upgraded.
@@ -251,6 +264,11 @@ impl Upgrade {
             .flat_map(|requirements| requirements.iter())
     }
 
+    /// Returns the set of dependency groups whose packages should be upgraded.
+    pub fn groups(&self) -> &FxHashSet<GroupName> {
+        &self.groups
+    }
+
     /// Combine a set of [`Upgrade`] values.
     #[must_use]
     pub fn combine(self, other: Self) -> Self {
@@ -277,9 +295,14 @@ impl Upgrade {
                 .extend(requirements);
         }
 
+        // For `groups`: always merge.
+        let mut combined_groups = self.groups;
+        combined_groups.extend(other.groups);
+
         Self {
             strategy,
             constraints: combined_constraints,
+            groups: combined_groups,
         }
     }
 }

crates/uv-requirements/src/upgrade.rs

@@ -1,10 +1,12 @@
 use std::path::Path;
 
 use anyhow::Result;
+use rustc_hash::FxHashSet;
 
 use uv_configuration::Upgrade;
 use uv_fs::CWD;
 use uv_git::ResolvedRepositoryReference;
+use uv_normalize::PackageName;
 use uv_requirements_txt::RequirementsTxt;
 use uv_resolver::{Lock, LockError, Preference, PreferenceError, PylockToml, PylockTomlErrorKind};
 
@@ -71,12 +73,17 @@ pub fn read_lock_requirements(
         return Ok(LockedRequirements::default());
     }
 
+    // Resolve `--upgrade-group` to a set of package names by collecting all dependencies from
+    // the specified groups across all workspace member packages in the lock.
+    let group_packages = resolve_group_packages(lock, upgrade);
+
     let mut preferences = Vec::new();
     let mut git = Vec::new();
 
     for package in lock.packages() {
-        // Skip the distribution if it's not included in the upgrade strategy.
-        if upgrade.contains(package.name()) {
+        // Skip the distribution if it's included in the upgrade strategy or belongs to an
+        // upgraded group.
+        if upgrade.contains(package.name()) || group_packages.contains(package.name()) {
             continue;
         }
 
@@ -94,6 +101,41 @@ pub fn read_lock_requirements(
     Ok(LockedRequirements { preferences, git })
 }
 
+/// Resolve the `--upgrade-group` group names to a set of package names by looking at the
+/// dependency groups defined on packages in the lockfile.
+fn resolve_group_packages(lock: &Lock, upgrade: &Upgrade) -> FxHashSet<PackageName> {
+    let groups = upgrade.groups();
+    if groups.is_empty() {
+        return FxHashSet::default();
+    }
+
+    let mut packages = FxHashSet::default();
+
+    // Check package-level dependency groups (the standard case for projects with a `[project]`
+    // table).
+    for package in lock.packages() {
+        for (group_name, dependencies) in package.resolved_dependency_groups() {
+            if groups.contains(group_name) {
+                for dependency in dependencies {
+                    packages.insert(dependency.package_name().clone());
+                }
+            }
+        }
+    }
+
+    // Check manifest-level dependency groups, which cover projects without a `[project]` table
+    // (e.g., virtual workspace roots or PEP 723 scripts).
+    for (group_name, requirements) in lock.dependency_groups() {
+        if groups.contains(group_name) {
+            for requirement in requirements {
+                packages.insert(requirement.name.clone());
+            }
+        }
+    }
+
+    packages
+}
+
 /// Load the preferred requirements from an existing `pylock.toml` file, applying the upgrade strategy.
 pub async fn read_pylock_toml_requirements(
     output_file: &Path,

crates/uv-settings/src/settings.rs

@@ -555,6 +555,7 @@ impl From<ResolverInstallerSchema> for ResolverInstallerOptions {
                     .flatten()
                     .map(Into::into)
                     .collect(),
+                Vec::new(),
             ),
             reinstall: Reinstall::from_args(reinstall, reinstall_package.unwrap_or_default()),
             no_build,
@@ -2006,6 +2007,7 @@ impl From<ResolverInstallerSchema> for ResolverOptions {
                     .flatten()
                     .map(Into::into)
                     .collect(),
+                Vec::new(),
             ),
             no_build: value.no_build,
             no_build_package: value.no_build_package,

crates/uv/src/commands/project/export.rs

@@ -448,6 +448,19 @@ fn cmd() -> String {
                 return Some(None);
             }
 
+            // Always skip the `--upgrade-group` and mark the next item to be skipped
+            if arg == "--upgrade-group" {
+                *skip_next = Some(true);
+                return Some(None);
+            }
+
+            // Skip only this argument if option and value are together
+            if arg.starts_with("--upgrade-group=") {
+                // Reset state; skip this iteration.
+                *skip_next = None;
+                return Some(None);
+            }
+
             // Always skip the `--quiet` flag.
             if arg == "--quiet" || arg == "-q" {
                 *skip_next = None;

crates/uv/src/commands/project/lock.rs

@@ -1193,10 +1193,12 @@ impl ValidatedLock {
             return Ok(Self::Preferable(lock));
         }
 
-        // If the user specified `--upgrade-package`, then at best we can prefer some of
-        // the existing versions.
+        // If the user specified `--upgrade-package` or `--upgrade-group`, then at best we can
+        // prefer some of the existing versions.
         if !(upgrade.is_none() || upgrade.is_all()) {
-            debug!("Resolving despite existing lockfile due to `--upgrade-package`");
+            debug!(
+                "Resolving despite existing lockfile due to `--upgrade-package` or `--upgrade-group`"
+            );
             return Ok(Self::Preferable(lock));
         }
 

crates/uv/src/settings.rs

@@ -996,6 +996,7 @@ impl ToolUpgradeSettings {
             python_platform,
             upgrade,
             upgrade_package,
+            upgrade_group,
             index_args,
             all,
             reinstall,
@@ -1035,6 +1036,7 @@ impl ToolUpgradeSettings {
             upgrade: upgrade_package.is_empty(),
             no_upgrade: false,
             upgrade_package,
+            upgrade_group,
             reinstall,
             no_reinstall,
             reinstall_package,
@@ -4021,6 +4023,7 @@ impl PipSettings {
                     .flatten()
                     .map(Requirement::from)
                     .collect(),
+                Vec::new(),
             )
             .combine(Upgrade::from_args(
                 upgrade,
@@ -4029,6 +4032,7 @@ impl PipSettings {
                     .flatten()
                     .map(Requirement::from)
                     .collect(),
+                Vec::new(),
             ))
             .unwrap_or_default(),
             reinstall: Reinstall::from_args(