Support extras and dependency_groups markers on uv pip install and uv pip sync

Author: charliermarsh

crates/uv-cli/src/lib.rs

@@ -1202,6 +1202,14 @@ pub struct PipCompileArgs {
     #[arg(long, overrides_with("all_extras"), hide = true)]
     pub no_all_extras: bool,
 
+    /// Install the specified dependency group from a `pyproject.toml`.
+    ///
+    /// If no path is provided, the `pyproject.toml` in the working directory is used.
+    ///
+    /// May be provided multiple times.
+    #[arg(long, group = "sources")]
+    pub group: Vec<PipGroupName>,
+
     #[command(flatten)]
     pub resolver: ResolverArgs,
 
@@ -1216,14 +1224,6 @@ pub struct PipCompileArgs {
     #[arg(long, overrides_with("no_deps"), hide = true)]
     pub deps: bool,
 
-    /// Install the specified dependency group from a `pyproject.toml`.
-    ///
-    /// If no path is provided, the `pyproject.toml` in the working directory is used.
-    ///
-    /// May be provided multiple times.
-    #[arg(long, group = "sources")]
-    pub group: Vec<PipGroupName>,
-
     /// Write the compiled requirements to the given `requirements.txt` or `pylock.toml` file.
     ///
     /// If the file already exists, the existing versions will be preferred when resolving
@@ -1518,6 +1518,30 @@ pub struct PipSyncArgs {
     #[arg(long, short, alias = "build-constraint", env = EnvVars::UV_BUILD_CONSTRAINT, value_delimiter = ' ', value_parser = parse_maybe_file_path)]
     pub build_constraints: Vec<Maybe<PathBuf>>,
 
+    /// Include optional dependencies from the specified extra name; may be provided more than once.
+    ///
+    /// Only applies to `pylock.toml`, `pyproject.toml`, `setup.py`, and `setup.cfg` sources.
+    #[arg(long, conflicts_with = "all_extras", value_parser = extra_name_with_clap_error)]
+    pub extra: Option<Vec<ExtraName>>,
+
+    /// Include all optional dependencies.
+    ///
+    /// Only applies to `pylock.toml`, `pyproject.toml`, `setup.py`, and `setup.cfg` sources.
+    #[arg(long, conflicts_with = "extra", overrides_with = "no_all_extras")]
+    pub all_extras: bool,
+
+    #[arg(long, overrides_with("all_extras"), hide = true)]
+    pub no_all_extras: bool,
+
+    /// Install the specified dependency group from a `pylock.toml` or `pyproject.toml`.
+    ///
+    /// If no path is provided, the `pylock.toml` or `pyproject.toml` in the working directory is
+    /// used.
+    ///
+    /// May be provided multiple times.
+    #[arg(long, group = "sources")]
+    pub group: Vec<PipGroupName>,
+
     #[command(flatten)]
     pub installer: InstallerArgs,
 
@@ -1798,19 +1822,28 @@ pub struct PipInstallArgs {
 
     /// Include optional dependencies from the specified extra name; may be provided more than once.
     ///
-    /// Only applies to `pyproject.toml`, `setup.py`, and `setup.cfg` sources.
+    /// Only applies to `pylock.toml`, `pyproject.toml`, `setup.py`, and `setup.cfg` sources.
     #[arg(long, conflicts_with = "all_extras", value_parser = extra_name_with_clap_error)]
     pub extra: Option<Vec<ExtraName>>,
 
     /// Include all optional dependencies.
     ///
-    /// Only applies to `pyproject.toml`, `setup.py`, and `setup.cfg` sources.
+    /// Only applies to `pylock.toml`, `pyproject.toml`, `setup.py`, and `setup.cfg` sources.
     #[arg(long, conflicts_with = "extra", overrides_with = "no_all_extras")]
     pub all_extras: bool,
 
     #[arg(long, overrides_with("all_extras"), hide = true)]
     pub no_all_extras: bool,
 
+    /// Install the specified dependency group from a `pylock.toml` or `pyproject.toml`.
+    ///
+    /// If no path is provided, the `pylock.toml` or `pyproject.toml` in the working directory is
+    /// used.
+    ///
+    /// May be provided multiple times.
+    #[arg(long, group = "sources")]
+    pub group: Vec<PipGroupName>,
+
     #[command(flatten)]
     pub installer: ResolverInstallerArgs,
 
@@ -1825,14 +1858,6 @@ pub struct PipInstallArgs {
     #[arg(long, overrides_with("no_deps"), hide = true)]
     pub deps: bool,
 
-    /// Install the specified dependency group from a `pyproject.toml`.
-    ///
-    /// If no path is provided, the `pyproject.toml` in the working directory is used.
-    ///
-    /// May be provided multiple times.
-    #[arg(long, group = "sources")]
-    pub group: Vec<PipGroupName>,
-
     /// Require a matching hash for each requirement.
     ///
     /// By default, uv will verify any available hashes in the requirements file, but will not

crates/uv-configuration/src/dependency_groups.rs

@@ -186,6 +186,18 @@ impl DependencyGroupsInner {
         self.include.names().chain(&self.exclude)
     }
 
+    /// Returns an iterator over all groups that are included in the specification,
+    /// assuming `all_names` is an iterator over all groups.
+    pub fn group_names<'a, Names>(
+        &'a self,
+        all_names: Names,
+    ) -> impl Iterator<Item = &'a GroupName> + 'a
+    where
+        Names: Iterator<Item = &'a GroupName> + 'a,
+    {
+        all_names.filter(move |name| self.contains(name))
+    }
+
     /// Iterate over all groups the user explicitly asked for on the CLI
     pub fn explicit_names(&self) -> impl Iterator<Item = &GroupName> {
         let DependencyGroupsHistory {

crates/uv-pep508/src/marker/tree.rs

@@ -739,6 +739,51 @@ impl Display for MarkerExpression {
     }
 }
 
+/// The extra and dependency group names to use when evaluating a marker tree.
+#[derive(Debug, Copy, Clone)]
+enum ExtrasEnvironment<'a> {
+    /// E.g., `extra == '...'`
+    Extras(&'a [ExtraName]),
+    /// E.g., `'...' in extras` or `'...' in dependency_groups`
+    PEP751(&'a [ExtraName], &'a [GroupName]),
+}
+
+impl<'a> ExtrasEnvironment<'a> {
+    /// Creates a new [`ExtrasEnvironment`] for the given `extra` names.
+    fn from_extras(extras: &'a [ExtraName]) -> Self {
+        Self::Extras(extras)
+    }
+
+    /// Creates a new [`ExtrasEnvironment`] for the given PEP 751 `extras` and `dependency_groups`.
+    fn from_pep751(extras: &'a [ExtraName], dependency_groups: &'a [GroupName]) -> Self {
+        Self::PEP751(extras, dependency_groups)
+    }
+
+    /// Returns the `extra` names in this environment.
+    fn extra(&self) -> &[ExtraName] {
+        match self {
+            ExtrasEnvironment::Extras(extra) => extra,
+            ExtrasEnvironment::PEP751(..) => &[],
+        }
+    }
+
+    /// Returns the `extras` names in this environment, as in a PEP 751 lockfile.
+    fn extras(&self) -> &[ExtraName] {
+        match self {
+            ExtrasEnvironment::Extras(..) => &[],
+            ExtrasEnvironment::PEP751(extras, ..) => extras,
+        }
+    }
+
+    /// Returns the `dependency_group` group names in this environment, as in a PEP 751 lockfile.
+    fn dependency_groups(&self) -> &[GroupName] {
+        match self {
+            ExtrasEnvironment::Extras(..) => &[],
+            ExtrasEnvironment::PEP751(.., groups) => groups,
+        }
+    }
+}
+
 /// Represents one or more nested marker expressions with and/or/parentheses.
 ///
 /// Marker trees are canonical, meaning any two functionally equivalent markers
@@ -986,7 +1031,27 @@ impl MarkerTree {
 
     /// Does this marker apply in the given environment?
     pub fn evaluate(self, env: &MarkerEnvironment, extras: &[ExtraName]) -> bool {
-        self.evaluate_reporter_impl(env, extras, &mut TracingReporter)
+        self.evaluate_reporter_impl(
+            env,
+            ExtrasEnvironment::from_extras(extras),
+            &mut TracingReporter,
+        )
+    }
+
+    /// Evaluate a marker in the context of a PEP 751 lockfile, which exposes several additional
+    /// markers (`extras` and `dependency_groups`) that are not available in any other context,
+    /// per the spec.
+    pub fn evaluate_pep751(
+        self,
+        env: &MarkerEnvironment,
+        extras: &[ExtraName],
+        groups: &[GroupName],
+    ) -> bool {
+        self.evaluate_reporter_impl(
+            env,
+            ExtrasEnvironment::from_pep751(extras, groups),
+            &mut TracingReporter,
+        )
     }
 
     /// Evaluates this marker tree against an optional environment and a
@@ -1003,7 +1068,11 @@ impl MarkerTree {
     ) -> bool {
         match env {
             None => self.evaluate_extras(extras),
-            Some(env) => self.evaluate_reporter_impl(env, extras, &mut TracingReporter),
+            Some(env) => self.evaluate_reporter_impl(
+                env,
+                ExtrasEnvironment::from_extras(extras),
+                &mut TracingReporter,
+            ),
         }
     }
 
@@ -1015,13 +1084,13 @@ impl MarkerTree {
         extras: &[ExtraName],
         reporter: &mut impl Reporter,
     ) -> bool {
-        self.evaluate_reporter_impl(env, extras, reporter)
+        self.evaluate_reporter_impl(env, ExtrasEnvironment::from_extras(extras), reporter)
     }
 
     fn evaluate_reporter_impl(
         self,
         env: &MarkerEnvironment,
-        extras: &[ExtraName],
+        extras: ExtrasEnvironment,
         reporter: &mut impl Reporter,
     ) -> bool {
         match self.kind() {
@@ -1073,12 +1142,18 @@ impl MarkerTree {
             }
             MarkerTreeKind::Extra(marker) => {
                 return marker
-                    .edge(extras.contains(marker.name().extra()))
+                    .edge(extras.extra().contains(marker.name().extra()))
+                    .evaluate_reporter_impl(env, extras, reporter);
+            }
+            MarkerTreeKind::Extras(marker) => {
+                return marker
+                    .edge(extras.extras().contains(marker.name().extra()))
                     .evaluate_reporter_impl(env, extras, reporter);
             }
-            // TODO(charlie): Add support for evaluating container extras in PEP 751 lockfiles.
-            MarkerTreeKind::Extras(..) | MarkerTreeKind::DependencyGroups(..) => {
-                return false;
+            MarkerTreeKind::DependencyGroups(marker) => {
+                return marker
+                    .edge(extras.dependency_groups().contains(marker.name().group()))
+                    .evaluate_reporter_impl(env, extras, reporter);
             }
         }
 

crates/uv-requirements/src/sources.rs

@@ -273,13 +273,13 @@ impl RequirementsSource {
     pub fn allows_extras(&self) -> bool {
         matches!(
             self,
-            Self::PyprojectToml(_) | Self::SetupPy(_) | Self::SetupCfg(_)
+            Self::PylockToml(_) | Self::PyprojectToml(_) | Self::SetupPy(_) | Self::SetupCfg(_)
         )
     }
 
     /// Returns `true` if the source allows groups to be specified.
     pub fn allows_groups(&self) -> bool {
-        matches!(self, Self::PyprojectToml(_))
+        matches!(self, Self::PylockToml(_) | Self::PyprojectToml(_))
     }
 }
 

crates/uv-requirements/src/specification.rs

@@ -250,10 +250,13 @@ impl RequirementsSpecification {
 
         // If we have a `pylock.toml`, don't allow additional requirements, constraints, or
         // overrides.
-        if requirements
-            .iter()
-            .any(|source| matches!(source, RequirementsSource::PylockToml(..)))
-        {
+        if let Some(pylock_toml) = requirements.iter().find_map(|source| {
+            if let RequirementsSource::PylockToml(path) = source {
+                Some(path)
+            } else {
+                None
+            }
+        }) {
             if requirements
                 .iter()
                 .any(|source| !matches!(source, RequirementsSource::PylockToml(..)))
@@ -272,22 +275,38 @@ impl RequirementsSpecification {
                     "Cannot specify constraints with a `pylock.toml` file"
                 ));
             }
-            if groups.is_some_and(|groups| !groups.groups.is_empty()) {
-                return Err(anyhow::anyhow!(
-                    "Cannot specify groups with a `pylock.toml` file"
-                ));
-            }
-        }
 
-        // Resolve sources into specifications so we know their `source_tree`.
-        let mut requirement_sources = Vec::new();
-        for source in requirements {
-            let source = Self::from_source(source, client_builder).await?;
-            requirement_sources.push(source);
-        }
+            // If we have a `pylock.toml`, disallow specifying paths for groups; instead, require
+            // that all groups refer to the `pylock.toml` file.
+            if let Some(groups) = groups {
+                let mut names = Vec::new();
+                for group in &groups.groups {
+                    if group.path.is_some() {
+                        return Err(anyhow::anyhow!(
+                            "Cannot specify paths for groups with a `pylock.toml` file; all groups must refer to the `pylock.toml` file"
+                        ));
+                    }
+                    names.push(group.name.clone());
+                }
 
-        // pip `--group` flags specify their own sources, which we need to process here
-        if let Some(groups) = groups {
+                if !names.is_empty() {
+                    spec.groups.insert(
+                        pylock_toml.clone(),
+                        DependencyGroups::from_args(
+                            false,
+                            false,
+                            false,
+                            Vec::new(),
+                            Vec::new(),
+                            false,
+                            names,
+                            false,
+                        ),
+                    );
+                }
+            }
+        } else if let Some(groups) = groups {
+            // pip `--group` flags specify their own sources, which we need to process here.
             // First, we collect all groups by their path.
             let mut groups_by_path = BTreeMap::new();
             for group in &groups.groups {
@@ -320,6 +339,13 @@ impl RequirementsSpecification {
             spec.groups = group_specs;
         }
 
+        // Resolve sources into specifications so we know their `source_tree`.
+        let mut requirement_sources = Vec::new();
+        for source in requirements {
+            let source = Self::from_source(source, client_builder).await?;
+            requirement_sources.push(source);
+        }
+
         // Read all requirements, and keep track of all requirements _and_ constraints.
         // A `requirements.txt` can contain a `-c constraints.txt` directive within it, so reading
         // a requirements file can also add constraints.

crates/uv-resolver/src/lock/export/pylock_toml.rs

@@ -188,11 +188,11 @@ pub struct PylockToml {
     #[serde(skip_serializing_if = "Option::is_none")]
     requires_python: Option<RequiresPython>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    extras: Vec<ExtraName>,
+    pub extras: Vec<ExtraName>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    dependency_groups: Vec<GroupName>,
+    pub dependency_groups: Vec<GroupName>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    default_groups: Vec<GroupName>,
+    pub default_groups: Vec<GroupName>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub packages: Vec<PylockTomlPackage>,
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
@@ -966,9 +966,12 @@ impl<'lock> PylockToml {
         self,
         install_path: &Path,
         markers: &MarkerEnvironment,
+        extras: &[ExtraName],
+        groups: &[GroupName],
         tags: &Tags,
         build_options: &BuildOptions,
     ) -> Result<Resolution, PylockTomlError> {
+        // Convert the extras and dependency groups specifications to a concrete environment.
         let mut graph =
             petgraph::graph::DiGraph::with_capacity(self.packages.len(), self.packages.len());
 
@@ -977,7 +980,7 @@ impl<'lock> PylockToml {
 
         for package in self.packages {
             // Omit packages that aren't relevant to the current environment.
-            if !package.marker.evaluate(markers, &[]) {
+            if !package.marker.evaluate_pep751(markers, extras, groups) {
                 continue;
             }