Adds group feature environment manager UI

src/api.ts

@@ -143,6 +143,33 @@ export interface PythonEnvironmentId {
     managerId: string;
 }
 
+/**
+ * Display information for an environment group.
+ */
+export interface EnvironmentGroupInfo {
+    /**
+     * The name of the environment group. This is used as an identifier for the group.
+     *
+     * Note: The first instance of the group with the given name will be used in the UI.
+     */
+    readonly name: string;
+
+    /**
+     * The description of the environment group.
+     */
+    readonly description?: string;
+
+    /**
+     * The tooltip for the environment group, which can be a string or a Markdown string.
+     */
+    readonly tooltip?: string | MarkdownString;
+
+    /**
+     * The icon path for the environment group, which can be a string, Uri, or an object with light and dark theme paths.
+     */
+    readonly iconPath?: IconPath;
+}
+
 /**
  * Interface representing information about a Python environment.
  */
@@ -202,6 +229,11 @@ export interface PythonEnvironmentInfo {
      * This is required by extension like Jupyter, Pylance, and other extensions to provide better experience with python.
      */
     readonly sysPrefix: string;
+
+    /**
+     * Optional `group` for this environment. This is used to group environments in the Environment Manager UI.
+     */
+    readonly group?: string | EnvironmentGroupInfo;
 }
 
 /**

src/features/envCommands.ts

@@ -29,6 +29,7 @@ import {
     ProjectEnvironment,
     ProjectPackageRootTreeItem,
     GlobalProjectItem,
+    EnvTreeItemKind,
 } from './views/treeViewItems';
 import { Common } from '../common/localize';
 import { pickEnvironment } from '../common/pickers/environments';
@@ -156,7 +157,8 @@ export async function createAnyEnvironmentCommand(
 export async function removeEnvironmentCommand(context: unknown, managers: EnvironmentManagers): Promise<void> {
     if (context instanceof PythonEnvTreeItem) {
         const view = context as PythonEnvTreeItem;
-        const manager = view.parent.manager;
+        const manager =
+            view.parent.kind === EnvTreeItemKind.environmentGroup ? view.parent.parent.manager : view.parent.manager;
         await manager.remove(view.environment);
     } else if (context instanceof Uri) {
         const manager = managers.getEnvironmentManager(context as Uri);

src/features/views/envManagersView.ts

@@ -1,5 +1,5 @@
 import { Disposable, Event, EventEmitter, ProviderResult, TreeDataProvider, TreeItem, TreeView, window } from 'vscode';
-import { PythonEnvironment } from '../../api';
+import { EnvironmentGroupInfo, PythonEnvironment } from '../../api';
 import {
     DidChangeEnvironmentManagerEventArgs,
     DidChangePackageManagerEventArgs,
@@ -19,6 +19,7 @@ import {
     NoPythonEnvTreeItem,
     EnvInfoTreeItem,
     PackageRootInfoTreeItem,
+    PythonGroupEnvTreeItem,
 } from './treeViewItems';
 import { createSimpleDebounce } from '../../common/utils/debounce';
 import { ProjectViews } from '../../common/localize';
@@ -97,21 +98,66 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
             const manager = (element as EnvManagerTreeItem).manager;
             const views: EnvTreeItem[] = [];
             const envs = await manager.getEnvironments('all');
-            envs.forEach((env) => {
+            envs.filter((e) => !e.group).forEach((env) => {
                 const view = new PythonEnvTreeItem(env, element as EnvManagerTreeItem);
                 views.push(view);
                 this.revealMap.set(env.envId.id, view);
             });
 
+            const groups: string[] = [];
+            const groupObjects: (string | EnvironmentGroupInfo)[] = [];
+            envs.filter((e) => e.group).forEach((env) => {
+                const name =
+                    env.group && typeof env.group === 'string' ? env.group : (env.group as EnvironmentGroupInfo).name;
+                if (name && !groups.includes(name)) {
+                    groups.push(name);
+                    groupObjects.push(env.group as EnvironmentGroupInfo);
+                }
+            });
+
+            groupObjects.forEach((group) => {
+                views.push(new PythonGroupEnvTreeItem(element as EnvManagerTreeItem, group));
+            });
+
             if (views.length === 0) {
                 views.push(new NoPythonEnvTreeItem(element as EnvManagerTreeItem));
             }
             return views;
         }
 
+        if (element.kind === EnvTreeItemKind.environmentGroup) {
+            const groupItem = element as PythonGroupEnvTreeItem;
+            const manager = groupItem.parent.manager;
+            const views: EnvTreeItem[] = [];
+            const envs = await manager.getEnvironments('all');
+            const groupName =
+                typeof groupItem.group === 'string' ? groupItem.group : (groupItem.group as EnvironmentGroupInfo).name;
+            const grouped = envs.filter((e) => {
+                if (e.group) {
+                    const name =
+                        e.group && typeof e.group === 'string' ? e.group : (e.group as EnvironmentGroupInfo).name;
+                    return name === groupName;
+                }
+                return false;
+            });
+
+            grouped.forEach((env) => {
+                const view = new PythonEnvTreeItem(env, groupItem);
+                views.push(view);
+                this.revealMap.set(env.envId.id, view);
+            });
+
+            return views;
+        }
+
         if (element.kind === EnvTreeItemKind.environment) {
-            const environment = (element as PythonEnvTreeItem).environment;
-            const envManager = (element as PythonEnvTreeItem).parent.manager;
+            const pythonEnvItem = element as PythonEnvTreeItem;
+            const environment = pythonEnvItem.environment;
+            const envManager =
+                pythonEnvItem.parent.kind === EnvTreeItemKind.environmentGroup
+                    ? pythonEnvItem.parent.parent.manager
+                    : pythonEnvItem.parent.manager;
+
             const pkgManager = this.getSupportedPackageManager(envManager);
             const parent = element as PythonEnvTreeItem;
             const views: EnvTreeItem[] = [];

src/features/views/treeViewItems.ts

@@ -1,12 +1,13 @@
 import { TreeItem, TreeItemCollapsibleState, MarkdownString, Command, ThemeIcon } from 'vscode';
 import { InternalEnvironmentManager, InternalPackageManager } from '../../internal.api';
-import { PythonEnvironment, IconPath, Package, PythonProject } from '../../api';
+import { PythonEnvironment, IconPath, Package, PythonProject, EnvironmentGroupInfo } from '../../api';
 import { removable } from './utils';
 import { isActivatableEnvironment } from '../common/activation';
 
 export enum EnvTreeItemKind {
     manager = 'python-env-manager',
     environment = 'python-env',
+    environmentGroup = 'python-env-group',
     noEnvironment = 'python-no-env',
     package = 'python-package',
     packageRoot = 'python-package-root',
@@ -42,11 +43,31 @@ export class EnvManagerTreeItem implements EnvTreeItem {
     }
 }
 
+export class PythonGroupEnvTreeItem implements EnvTreeItem {
+    public readonly kind = EnvTreeItemKind.environmentGroup;
+    public readonly treeItem: TreeItem;
+    constructor(public readonly parent: EnvManagerTreeItem, public readonly group: string | EnvironmentGroupInfo) {
+        const label = typeof group === 'string' ? group : group.name;
+        const item = new TreeItem(label, TreeItemCollapsibleState.Collapsed);
+        item.contextValue = `pythonEnvGroup;${this.parent.manager.id}:${label};`;
+        this.treeItem = item;
+
+        if (typeof group !== 'string') {
+            item.description = group.description;
+            item.tooltip = group.tooltip;
+            item.iconPath = group.iconPath;
+        }
+    }
+}
+
 export class PythonEnvTreeItem implements EnvTreeItem {
     public readonly kind = EnvTreeItemKind.environment;
     public readonly treeItem: TreeItem;
-    constructor(public readonly environment: PythonEnvironment, public readonly parent: EnvManagerTreeItem) {
-        const item = new TreeItem(environment.displayName, TreeItemCollapsibleState.Collapsed);
+    constructor(
+        public readonly environment: PythonEnvironment,
+        public readonly parent: EnvManagerTreeItem | PythonGroupEnvTreeItem,
+    ) {
+        const item = new TreeItem(environment.displayName ?? environment.name, TreeItemCollapsibleState.Collapsed);
         item.contextValue = this.getContextValue();
         item.description = environment.description;
         item.tooltip = environment.tooltip;
@@ -56,7 +77,12 @@ export class PythonEnvTreeItem implements EnvTreeItem {
 
     private getContextValue() {
         const activatable = isActivatableEnvironment(this.environment) ? 'activatable' : '';
-        const remove = this.parent.manager.supportsRemove ? 'remove' : '';
+        let remove = '';
+        if (this.parent.kind === EnvTreeItemKind.environmentGroup) {
+            remove = this.parent.parent.manager.supportsRemove ? 'remove' : '';
+        } else if (this.parent.kind === EnvTreeItemKind.manager) {
+            remove = this.parent.manager.supportsRemove ? 'remove' : '';
+        }
         const parts = ['pythonEnvironment', remove, activatable].filter(Boolean);
         return parts.join(';') + ';';
     }

src/internal.api.ts

@@ -24,6 +24,7 @@ import {
     ResolveEnvironmentContext,
     PackageInstallOptions,
     Installable,
+    EnvironmentGroupInfo,
 } from './api';
 import { CreateEnvironmentNotSupported, RemoveEnvironmentNotSupported } from './common/errors/NotSupportedError';
 
@@ -268,6 +269,7 @@ export class PythonEnvironmentImpl implements PythonEnvironment {
     public readonly iconPath?: IconPath;
     public readonly execInfo: PythonEnvironmentExecutionInfo;
     public readonly sysPrefix: string;
+    public readonly group?: string | EnvironmentGroupInfo;
 
     constructor(public readonly envId: PythonEnvironmentId, info: PythonEnvironmentInfo) {
         this.name = info.name;
@@ -281,6 +283,7 @@ export class PythonEnvironmentImpl implements PythonEnvironment {
         this.iconPath = info.iconPath;
         this.execInfo = info.execInfo;
         this.sysPrefix = info.sysPrefix;
+        this.group = info.group;
     }
 }
 

src/managers/conda/condaUtils.ts

@@ -270,6 +270,7 @@ function nativeToPythonEnv(
                     activation: [{ executable: conda, args: ['activate', e.prefix] }],
                     deactivation: [{ executable: conda, args: ['deactivate'] }],
                 },
+                group: 'Prefix',
             },
             manager,
         );
@@ -297,6 +298,7 @@ function nativeToPythonEnv(
                     activation: [{ executable: conda, args: ['activate', name] }],
                     deactivation: [{ executable: conda, args: ['deactivate'] }],
                 },
+                group: 'Named',
             },
             manager,
         );
@@ -490,6 +492,7 @@ async function createNamedCondaEnvironment(
                             run: { executable: path.join(envPath, bin) },
                         },
                         sysPrefix: envPath,
+                        group: 'Named',
                     },
                     manager,
                 );
@@ -565,6 +568,7 @@ async function createPrefixCondaEnvironment(
                             deactivation: [{ executable: 'conda', args: ['deactivate'] }],
                         },
                         sysPrefix: prefix,
+                        group: 'Prefix',
                     },
                     manager,
                 );