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/data.py

@@ -27,12 +27,61 @@ 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
+        """
+        from packaging.requirements import Requirement
+
+        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/project.py

@@ -52,9 +52,12 @@ def enabled(self) -> bool:
         """
         return self._enabled
 
-    def install(self) -> None:
+    def install(self, groups: list[str] | None = None) -> None:
         """Installs project dependencies
 
+        Args:
+            groups: Optional list of dependency groups to install in addition to base dependencies
+
         Raises:
             Exception: Provider-specific exceptions are propagated with full context
         """
@@ -66,17 +69,28 @@ def install(self) -> None:
         asyncio.run(self._data.download_provider_tools())
 
         self.logger.info('Installing project')
+
+        # Log active groups
+        if groups:
+            self.logger.info('Installing with dependency groups: %s', ', '.join(groups))
+
         self.logger.info('Installing %s provider', self._data.plugins.provider.name())
 
+        # Validate and log active groups
+        self._data.apply_dependency_groups(groups)
+
         # Sync before install to allow provider to access generator's resolved configuration
         self._data.sync()
 
         # Let provider handle its own exceptions for better error context
-        self._data.plugins.provider.install()
+        self._data.plugins.provider.install(groups=groups)
 
-    def update(self) -> None:
+    def update(self, groups: list[str] | None = None) -> None:
         """Updates project dependencies
 
+        Args:
+            groups: Optional list of dependency groups to update in addition to base dependencies
+
         Raises:
             Exception: Provider-specific exception
         """
@@ -88,13 +102,21 @@ def update(self) -> None:
         asyncio.run(self._data.download_provider_tools())
 
         self.logger.info('Updating project')
+
+        # Log active groups
+        if groups:
+            self.logger.info('Updating with dependency groups: %s', ', '.join(groups))
+
         self.logger.info('Updating %s provider', self._data.plugins.provider.name())
 
+        # Validate and log active groups
+        self._data.apply_dependency_groups(groups)
+
         # Sync before update to allow provider to access generator's resolved configuration
         self._data.sync()
 
         # Let provider handle its own exceptions for better error context
-        self._data.plugins.provider.update()
+        self._data.plugins.provider.update(groups=groups)
 
     def publish(self) -> None:
         """Publishes the project

cppython/schema.py

@@ -8,11 +8,19 @@ class API(Protocol):
     """Project API specification"""
 
     @abstractmethod
-    def install(self) -> None:
-        """Installs project dependencies"""
+    def install(self, groups: list[str] | None = None) -> None:
+        """Installs project dependencies
+
+        Args:
+            groups: Optional list of dependency groups to install
+        """
         raise NotImplementedError()
 
     @abstractmethod
-    def update(self) -> None:
-        """Updates project dependencies"""
+    def update(self, groups: list[str] | None = None) -> None:
+        """Updates project dependencies
+
+        Args:
+            groups: Optional list of dependency groups to update
+        """
         raise NotImplementedError()