Group CLI

Author: Behemyth

cppython/console/entry.py

@@ -30,6 +30,47 @@ def get_enabled_project(context: typer.Context) -> Project:
     return project
 
 
+def _parse_groups_argument(groups: str | None) -> list[str] | None:
+    """Parse pip-style dependency groups from command argument.
+
+    Args:
+        groups: Groups string like '[test]' or '[dev,test]' or None
+
+    Returns:
+        List of group names or None if no groups specified
+
+    Raises:
+        typer.BadParameter: If the groups format is invalid
+    """
+    if groups is None:
+        return None
+
+    # Strip whitespace
+    groups = groups.strip()
+
+    if not groups:
+        return None
+
+    # Check for square brackets
+    if not (groups.startswith('[') and groups.endswith(']')):
+        raise typer.BadParameter(f"Invalid groups format: '{groups}'. Use square brackets like: [test] or [dev,test]")
+
+    # Extract content between brackets and split by comma
+    content = groups[1:-1].strip()
+
+    if not content:
+        raise typer.BadParameter('Empty groups specification. Provide at least one group name.')
+
+    # Split by comma and strip whitespace from each group
+    group_list = [g.strip() for g in content.split(',')]
+
+    # Validate group names are not empty
+    if any(not g for g in group_list):
+        raise typer.BadParameter('Group names cannot be empty.')
+
+    return group_list
+
+
 def _find_pyproject_file() -> Path:
     """Searches upward for a pyproject.toml file
 
@@ -83,33 +124,57 @@ def info(
 @app.command()
 def install(
     context: typer.Context,
+    groups: Annotated[
+        str | None,
+        typer.Argument(
+            help='Dependency groups to install in addition to base dependencies. '
+            'Use square brackets like: [test] or [dev,test]'
+        ),
+    ] = None,
 ) -> None:
     """Install API call
 
     Args:
         context: The CLI configuration object
+        groups: Optional dependency groups to install (e.g., [test] or [dev,test])
 
     Raises:
         ValueError: If the configuration object is missing
     """
     project = get_enabled_project(context)
-    project.install()
+
+    # Parse groups from pip-style syntax
+    group_list = _parse_groups_argument(groups)
+
+    project.install(groups=group_list)
 
 
 @app.command()
 def update(
     context: typer.Context,
+    groups: Annotated[
+        str | None,
+        typer.Argument(
+            help='Dependency groups to update in addition to base dependencies. '
+            'Use square brackets like: [test] or [dev,test]'
+        ),
+    ] = None,
 ) -> None:
     """Update API call
 
     Args:
         context: The CLI configuration object
+        groups: Optional dependency groups to update (e.g., [test] or [dev,test])
 
     Raises:
         ValueError: If the configuration object is missing
     """
     project = get_enabled_project(context)
-    project.update()
+
+    # Parse groups from pip-style syntax
+    group_list = _parse_groups_argument(groups)
+
+    project.update(groups=group_list)
 
 
 @app.command(name='list')

cppython/core/plugin_schema/provider.py

@@ -80,13 +80,21 @@ def features(directory: DirectoryPath) -> SupportedFeatures:
         raise NotImplementedError
 
     @abstractmethod
-    def install(self) -> None:
-        """Called when dependencies need to be installed from a lock file."""
+    def install(self, groups: list[str] | None = None) -> None:
+        """Called when dependencies need to be installed from a lock file.
+
+        Args:
+            groups: Optional list of dependency group names to install in addition to base dependencies
+        """
         raise NotImplementedError
 
     @abstractmethod
-    def update(self) -> None:
-        """Called when dependencies need to be updated and written to the lock file."""
+    def update(self, groups: list[str] | None = None) -> None:
+        """Called when dependencies need to be updated and written to the lock file.
+
+        Args:
+            groups: Optional list of dependency group names to update in addition to base dependencies
+        """
         raise NotImplementedError
 
     @abstractmethod

cppython/core/resolution.py

@@ -76,6 +76,21 @@ def resolve_pep621(
     return pep621_data
 
 
+def _resolve_absolute_path(path: Path, root_directory: Path) -> Path:
+    """Convert a path to absolute, using root_directory as base for relative paths.
+
+    Args:
+        path: The path to resolve
+        root_directory: The base directory for relative paths
+
+    Returns:
+        The absolute path
+    """
+    if path.is_absolute():
+        return path
+    return root_directory / path
+
+
 class PluginBuildData(CPPythonModel):
     """Data needed to construct CoreData"""
 
@@ -114,34 +129,20 @@ def resolve_cppython(
     """
     root_directory = project_data.project_root.absolute()
 
-    # Add the base path to all relative paths
+    # Resolve configuration path
     modified_configuration_path = local_configuration.configuration_path
-
-    # TODO: Grab configuration from the project, user, or system
     if modified_configuration_path is None:
         modified_configuration_path = root_directory / 'cppython.json'
+    else:
+        modified_configuration_path = _resolve_absolute_path(modified_configuration_path, root_directory)
 
-    if not modified_configuration_path.is_absolute():
-        modified_configuration_path = root_directory / modified_configuration_path
-
-    modified_install_path = local_configuration.install_path
-
-    if not modified_install_path.is_absolute():
-        modified_install_path = root_directory / modified_install_path
-
-    modified_tool_path = local_configuration.tool_path
-
-    if not modified_tool_path.is_absolute():
-        modified_tool_path = root_directory / modified_tool_path
-
-    modified_build_path = local_configuration.build_path
-
-    if not modified_build_path.is_absolute():
-        modified_build_path = root_directory / modified_build_path
+    # Resolve other paths
+    modified_install_path = _resolve_absolute_path(local_configuration.install_path, root_directory)
+    modified_tool_path = _resolve_absolute_path(local_configuration.tool_path, root_directory)
+    modified_build_path = _resolve_absolute_path(local_configuration.build_path, root_directory)
 
     modified_provider_name = plugin_build_data.provider_name
     modified_generator_name = plugin_build_data.generator_name
-
     modified_scm_name = plugin_build_data.scm_name
 
     # Extract provider and generator configuration data

cppython/data.py

@@ -3,6 +3,8 @@
 from dataclasses import dataclass
 from logging import Logger
 
+from packaging.requirements import Requirement
+
 from cppython.core.plugin_schema.generator import Generator
 from cppython.core.plugin_schema.provider import Provider
 from cppython.core.plugin_schema.scm import SCM
@@ -27,12 +29,59 @@ def __init__(self, core_data: CoreData, plugins: Plugins, logger: Logger) -> Non
         self._core_data = core_data
         self._plugins = plugins
         self.logger = logger
+        self._active_groups: list[str] | None = None
 
     @property
     def plugins(self) -> Plugins:
         """The plugin data for CPPython"""
         return self._plugins
 
+    def set_active_groups(self, groups: list[str] | None) -> None:
+        """Set the active dependency groups for the current operation.
+
+        Args:
+            groups: List of group names to activate, or None for no additional groups
+        """
+        self._active_groups = groups
+        if groups:
+            self.logger.info('Active dependency groups: %s', ', '.join(groups))
+
+            # Validate that requested groups exist
+            available_groups = set(self._core_data.cppython_data.dependency_groups.keys())
+            requested_groups = set(groups)
+            missing_groups = requested_groups - available_groups
+
+            if missing_groups:
+                self.logger.warning(
+                    'Requested dependency groups not found: %s. Available groups: %s',
+                    ', '.join(sorted(missing_groups)),
+                    ', '.join(sorted(available_groups)) if available_groups else 'none',
+                )
+
+    def apply_dependency_groups(self, groups: list[str] | None) -> None:
+        """Validate and log the dependency groups to be used.
+
+        Args:
+            groups: List of group names to apply, or None for base dependencies only
+        """
+        if groups:
+            self.set_active_groups(groups)
+
+    def get_active_dependencies(self) -> list:
+        """Get the combined list of base dependencies and active group dependencies.
+
+        Returns:
+            Combined list of Requirement objects from base and active groups
+        """
+        dependencies: list[Requirement] = list(self._core_data.cppython_data.dependencies)
+
+        if self._active_groups:
+            for group_name in self._active_groups:
+                if group_name in self._core_data.cppython_data.dependency_groups:
+                    dependencies.extend(self._core_data.cppython_data.dependency_groups[group_name])
+
+        return dependencies
+
     def sync(self) -> None:
         """Gathers sync information from providers and passes it to the generator
 

cppython/plugins/conan/plugin.py

@@ -69,19 +69,20 @@ def information() -> Information:
         """
         return Information()
 
-    def _install_dependencies(self, *, update: bool = False) -> None:
+    def _install_dependencies(self, *, update: bool = False, groups: list[str] | None = None) -> None:
         """Install/update dependencies using Conan CLI.
 
         Args:
             update: If True, check remotes for newer versions/revisions and install those.
                    If False, use cached versions when available.
+            groups: Optional list of dependency group names to include
         """
         operation = 'update' if update else 'install'
         logger = getLogger('cppython.conan')
 
         try:
             # Setup environment and generate conanfile
-            conanfile_path = self._prepare_installation()
+            conanfile_path = self._prepare_installation(groups=groups)
         except Exception as e:
             raise ProviderInstallationError('conan', f'Failed to prepare {operation} environment: {e}', e) from e
 
@@ -93,20 +94,27 @@ def _install_dependencies(self, *, update: bool = False) -> None:
         except Exception as e:
             raise ProviderInstallationError('conan', f'Failed to install dependencies: {e}', e) from e
 
-    def _prepare_installation(self) -> Path:
+    def _prepare_installation(self, groups: list[str] | None = None) -> Path:
         """Prepare the installation environment and generate conanfile.
 
+        Args:
+            groups: Optional list of dependency group names to include
+
         Returns:
             Path to conanfile.py
         """
-        # Resolve dependencies and generate conanfile.py
+        # Resolve base dependencies
         resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
 
-        # Resolve dependency groups
-        resolved_dependency_groups = {
-            group_name: [resolve_conan_dependency(req) for req in group_requirements]
-            for group_name, group_requirements in self.core_data.cppython_data.dependency_groups.items()
-        }
+        # Resolve only the requested dependency groups
+        resolved_dependency_groups = {}
+        if groups:
+            for group_name in groups:
+                if group_name in self.core_data.cppython_data.dependency_groups:
+                    resolved_dependency_groups[group_name] = [
+                        resolve_conan_dependency(req)
+                        for req in self.core_data.cppython_data.dependency_groups[group_name]
+                    ]
 
         self.builder.generate_conanfile(
             self.core_data.project_data.project_root,
@@ -180,13 +188,21 @@ def _run_conan_install(self, conanfile_path: Path, update: bool, build_type: str
             logger.error('Conan install failed: %s', error_msg, exc_info=True)
             raise ProviderInstallationError('conan', error_msg, e) from e
 
-    def install(self) -> None:
-        """Installs the provider"""
-        self._install_dependencies(update=False)
+    def install(self, groups: list[str] | None = None) -> None:
+        """Installs the provider
+
+        Args:
+            groups: Optional list of dependency group names to install
+        """
+        self._install_dependencies(update=False, groups=groups)
+
+    def update(self, groups: list[str] | None = None) -> None:
+        """Updates the provider
 
-    def update(self) -> None:
-        """Updates the provider"""
-        self._install_dependencies(update=True)
+        Args:
+            groups: Optional list of dependency group names to update
+        """
+        self._install_dependencies(update=True, groups=groups)
 
     @staticmethod
     def supported_sync_type(sync_type: type[SyncData]) -> bool:

cppython/plugins/vcpkg/plugin.py

@@ -231,8 +231,12 @@ async def download_tooling(cls, directory: Path) -> None:
 
         cls._update_provider(directory)
 
-    def install(self) -> None:
-        """Called when dependencies need to be installed from a lock file."""
+    def install(self, groups: list[str] | None = None) -> None:
+        """Called when dependencies need to be installed from a lock file.
+
+        Args:
+            groups: Optional list of dependency group names to install (currently not used by vcpkg)
+        """
         manifest_directory = self.core_data.project_data.project_root
         manifest = generate_manifest(self.core_data, self.data)
 
@@ -257,8 +261,12 @@ def install(self) -> None:
         except subprocess.CalledProcessError as e:
             self._handle_subprocess_error(logger, 'install project dependencies', e, ProviderInstallationError)
 
-    def update(self) -> None:
-        """Called when dependencies need to be updated and written to the lock file."""
+    def update(self, groups: list[str] | None = None) -> None:
+        """Called when dependencies need to be updated and written to the lock file.
+
+        Args:
+            groups: Optional list of dependency group names to update (currently not used by vcpkg)
+        """
         manifest_directory = self.core_data.project_data.project_root
 
         manifest = generate_manifest(self.core_data, self.data)