feat: Add support for Quick Create

karthiknadig · karthiknadig · commit 8e1887aa6acc · 2025-04-10T10:28:26.000-07:00
diff --git a/src/api.ts b/src/api.ts
@@ -316,6 +316,18 @@ export type DidChangeEnvironmentsEventArgs = {
  */
 export type ResolveEnvironmentContext = Uri;
 
+export interface QuickCreateConfig {
+    /**
+     * The description of the quick create step.
+     */
+    readonly description: string;
+
+    /**
+     * The detail of the quick create step.
+     */
+    readonly detail?: string;
+}
+
 /**
  * Interface representing an environment manager.
  */
@@ -360,12 +372,22 @@ export interface EnvironmentManager {
      */
     readonly log?: LogOutputChannel;
 
+    /**
+     * The quick create details for the environment manager. Having this method also enables the quick create feature
+     * for the environment manager.
+     */
+    quickCreateConfig?(): QuickCreateConfig | undefined;
+
     /**
      * Creates a new Python environment within the specified scope.
      * @param scope - The scope within which to create the environment.
+     * @param options - Optional parameters for creating the Python environment.
      * @returns A promise that resolves to the created Python environment, or undefined if creation failed.
      */
-    create?(scope: CreateEnvironmentScope): Promise<PythonEnvironment | undefined>;
+    create?(
+        scope: CreateEnvironmentScope,
+        options: CreateEnvironmentOptions | undefined,
+    ): Promise<PythonEnvironment | undefined>;
 
     /**
      * Removes the specified Python environment.
@@ -747,6 +769,25 @@ export type PackageManagementOptions =
           uninstall: string[];
       };
 
+/**
+ * Options for creating a Python environment.
+ */
+export interface CreateEnvironmentOptions {
+    /**
+     * Provides some context about quick create based on user input.
+     *   - if true, the environment should be created without any user input or prompts.
+     *   - if false, the environment creation can show user input or prompts.
+     *     This also means user explicitly skipped the quick create option.
+     *   - if undefined, the environment creation can show user input or prompts.
+     *     You can show quick create option to the user if you support it.
+     */
+    quickCreate?: boolean;
+    /**
+     * Packages to install in addition to the automatically picked packages as a part of creating environment.
+     */
+    additionalPackages?: string[];
+}
+
 export interface PythonProcess {
     /**
      * The process ID of the Python process.
@@ -807,9 +848,13 @@ export interface PythonEnvironmentManagementApi {
      * Create a Python environment using environment manager associated with the scope.
      *
      * @param scope Where the environment is to be created.
+     * @param options Optional parameters for creating the Python environment.
      * @returns The Python environment created. `undefined` if not created.
      */
-    createEnvironment(scope: CreateEnvironmentScope): Promise<PythonEnvironment | undefined>;
+    createEnvironment(
+        scope: CreateEnvironmentScope,
+        options: CreateEnvironmentOptions | undefined,
+    ): Promise<PythonEnvironment | undefined>;
 
     /**
      * Remove a Python environment.
diff --git a/src/common/localize.ts b/src/common/localize.ts
@@ -11,6 +11,7 @@ export namespace Common {
     export const viewLogs = l10n.t('View Logs');
     export const yes = l10n.t('Yes');
     export const no = l10n.t('No');
+    export const quickCreate = l10n.t('Quick Create');
 }
 
 export namespace Interpreter {
diff --git a/src/common/pickers/environments.ts b/src/common/pickers/environments.ts
@@ -80,7 +80,10 @@ async function createEnvironment(
     const manager = managers.find((m) => m.id === managerId);
     if (manager) {
         try {
-            const env = await manager.create(options.projects.map((p) => p.uri));
+            const env = await manager.create(
+                options.projects.map((p) => p.uri),
+                undefined,
+            );
             return env;
         } catch (ex) {
             if (ex === QuickInputButtons.Back) {
diff --git a/src/common/pickers/managers.ts b/src/common/pickers/managers.ts
@@ -4,6 +4,20 @@ import { InternalEnvironmentManager, InternalPackageManager } from '../../intern
 import { Common, Pickers } from '../localize';
 import { showQuickPickWithButtons, showQuickPick } from '../window.apis';
 
+function getDescription(mgr: InternalEnvironmentManager | InternalPackageManager): string | undefined {
+    if (mgr.description) {
+        return mgr.description;
+    }
+    if (mgr.tooltip) {
+        const tooltip = mgr.tooltip;
+        if (typeof tooltip === 'string') {
+            return tooltip;
+        }
+        return tooltip.value;
+    }
+    return undefined;
+}
+
 export async function pickEnvironmentManager(
     managers: InternalEnvironmentManager[],
     defaultManagers?: InternalEnvironmentManager[],
@@ -18,14 +32,25 @@ export async function pickEnvironmentManager(
 
     const items: (QuickPickItem | (QuickPickItem & { id: string }))[] = [];
     if (defaultManagers && defaultManagers.length > 0) {
+        items.push({
+            label: Common.recommended,
+            kind: QuickPickItemKind.Separator,
+        });
+        if (defaultManagers.length === 1 && defaultManagers[0].supportsQuickCreate) {
+            const details = defaultManagers[0].quickCreateConfig();
+            if (details) {
+                items.push({
+                    label: Common.quickCreate,
+                    description: details.description,
+                    detail: details.detail,
+                    id: `QuickCreate#${defaultManagers[0].id}`,
+                });
+            }
+        }
         items.push(
-            {
-                label: Common.recommended,
-                kind: QuickPickItemKind.Separator,
-            },
             ...defaultManagers.map((defaultMgr) => ({
                 label: defaultMgr.displayName,
-                description: defaultMgr.description,
+                description: getDescription(defaultMgr),
                 id: defaultMgr.id,
             })),
             {
@@ -39,7 +64,7 @@ export async function pickEnvironmentManager(
             .filter((m) => !defaultManagers?.includes(m))
             .map((m) => ({
                 label: m.displayName,
-                description: m.description,
+                description: getDescription(m),
                 id: m.id,
             })),
     );
@@ -71,7 +96,7 @@ export async function pickPackageManager(
             },
             ...defaultManagers.map((defaultMgr) => ({
                 label: defaultMgr.displayName,
-                description: defaultMgr.description,
+                description: getDescription(defaultMgr),
                 id: defaultMgr.id,
             })),
             {
@@ -85,7 +110,7 @@ export async function pickPackageManager(
             .filter((m) => !defaultManagers?.includes(m))
             .map((m) => ({
                 label: m.displayName,
-                description: m.description,
+                description: getDescription(m),
                 id: m.id,
             })),
     );
diff --git a/src/features/envCommands.ts b/src/features/envCommands.ts
@@ -7,7 +7,13 @@ import {
     PythonProjectManager,
 } from '../internal.api';
 import { traceError, traceInfo, traceVerbose } from '../common/logging';
-import { PythonEnvironment, PythonEnvironmentApi, PythonProject, PythonProjectCreator } from '../api';
+import {
+    CreateEnvironmentOptions,
+    PythonEnvironment,
+    PythonEnvironmentApi,
+    PythonProject,
+    PythonProjectCreator,
+} from '../api';
 import * as path from 'path';
 import {
     setEnvironmentManager,
@@ -75,7 +81,7 @@ export async function createEnvironmentCommand(
         const manager = (context as EnvManagerTreeItem).manager;
         const projects = pm.getProjects();
         if (projects.length === 0) {
-            const env = await manager.create('global');
+            const env = await manager.create('global', undefined);
             if (env) {
                 await em.setEnvironments('global', env);
             }
@@ -84,7 +90,7 @@ export async function createEnvironmentCommand(
             const selected = await pickProjectMany(projects);
             if (selected) {
                 const scope = selected.length === 0 ? 'global' : selected.map((p) => p.uri);
-                const env = await manager.create(scope);
+                const env = await manager.create(scope, undefined);
                 if (env) {
                     await em.setEnvironments(scope, env);
                 }
@@ -97,7 +103,7 @@ export async function createEnvironmentCommand(
         const manager = em.getEnvironmentManager(context as Uri);
         const project = pm.get(context as Uri);
         if (project) {
-            return await manager?.create(project.uri);
+            return await manager?.create(project.uri, undefined);
         } else {
             traceError(`No project found for ${context}`);
         }
@@ -109,16 +115,15 @@ export async function createEnvironmentCommand(
 export async function createAnyEnvironmentCommand(
     em: EnvironmentManagers,
     pm: PythonProjectManager,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    options?: any,
+    options?: CreateEnvironmentOptions & { selectEnvironment: boolean },
 ): Promise<PythonEnvironment | undefined> {
     const select = options?.selectEnvironment;
     const projects = pm.getProjects();
     if (projects.length === 0) {
         const managerId = await pickEnvironmentManager(em.managers.filter((m) => m.supportsCreate));
         const manager = em.managers.find((m) => m.id === managerId);
         if (manager) {
-            const env = await manager.create('global');
+            const env = await manager.create('global', { ...options });
             if (select && env) {
                 await manager.set(undefined, env);
             }
@@ -137,14 +142,22 @@ export async function createAnyEnvironmentCommand(
                 }
             });
 
-            const managerId = await pickEnvironmentManager(
+            let managerId = await pickEnvironmentManager(
                 em.managers.filter((m) => m.supportsCreate),
                 defaultManagers,
             );
+            let quickCreate = false;
+            if (managerId?.startsWith('QuickCreate#')) {
+                quickCreate = true;
+                managerId = managerId.replace('QuickCreate#', '');
+            }
 
             const manager = em.managers.find((m) => m.id === managerId);
             if (manager) {
-                const env = await manager.create(selected.map((p) => p.uri));
+                const env = await manager.create(
+                    selected.map((p) => p.uri),
+                    { ...options, quickCreate },
+                );
                 if (select && env) {
                     await em.setEnvironments(
                         selected.map((p) => p.uri),
diff --git a/src/features/pythonApi.ts b/src/features/pythonApi.ts
@@ -28,6 +28,7 @@ import {
     PythonBackgroundRunOptions,
     PythonTerminalCreateOptions,
     DidChangeEnvironmentVariablesEventArgs,
+    CreateEnvironmentOptions,
 } from '../api';
 import {
     EnvironmentManagers,
@@ -116,7 +117,10 @@ class PythonEnvironmentApiImpl implements PythonEnvironmentApi {
         return new PythonEnvironmentImpl(envId, info);
     }
 
-    async createEnvironment(scope: CreateEnvironmentScope): Promise<PythonEnvironment | undefined> {
+    async createEnvironment(
+        scope: CreateEnvironmentScope,
+        options: CreateEnvironmentOptions | undefined,
+    ): Promise<PythonEnvironment | undefined> {
         if (scope === 'global' || (!Array.isArray(scope) && scope instanceof Uri)) {
             const manager = this.envManagers.getEnvironmentManager(scope === 'global' ? undefined : scope);
             if (!manager) {
@@ -125,9 +129,9 @@ class PythonEnvironmentApiImpl implements PythonEnvironmentApi {
             if (!manager.supportsCreate) {
                 throw new Error(`Environment manager does not support creating environments: ${manager.id}`);
             }
-            return manager.create(scope);
+            return manager.create(scope, options);
         } else if (Array.isArray(scope) && scope.length === 1 && scope[0] instanceof Uri) {
-            return this.createEnvironment(scope[0]);
+            return this.createEnvironment(scope[0], options);
         } else if (Array.isArray(scope) && scope.length > 0 && scope.every((s) => s instanceof Uri)) {
             const managers: InternalEnvironmentManager[] = [];
             scope.forEach((s) => {
@@ -151,7 +155,7 @@ class PythonEnvironmentApiImpl implements PythonEnvironmentApi {
                 throw new Error('No environment manager found');
             }
 
-            const result = await manager.create(scope);
+            const result = await manager.create(scope, options);
             return result;
         }
     }
diff --git a/src/internal.api.ts b/src/internal.api.ts
@@ -24,6 +24,8 @@ import {
     ResolveEnvironmentContext,
     PackageManagementOptions,
     EnvironmentGroupInfo,
+    QuickCreateConfig,
+    CreateEnvironmentOptions,
 } from './api';
 import { CreateEnvironmentNotSupported, RemoveEnvironmentNotSupported } from './common/errors/NotSupportedError';
 
@@ -141,14 +143,28 @@ export class InternalEnvironmentManager implements EnvironmentManager {
         return this.manager.create !== undefined;
     }
 
-    create(scope: CreateEnvironmentScope): Promise<PythonEnvironment | undefined> {
+    create(
+        scope: CreateEnvironmentScope,
+        options: CreateEnvironmentOptions | undefined,
+    ): Promise<PythonEnvironment | undefined> {
         if (this.manager.create) {
-            return this.manager.create(scope);
+            return this.manager.create(scope, options);
         }
 
         return Promise.reject(new CreateEnvironmentNotSupported(`Create Environment not supported by: ${this.id}`));
     }
 
+    public get supportsQuickCreate(): boolean {
+        return this.manager.quickCreateConfig !== undefined;
+    }
+
+    quickCreateConfig(): QuickCreateConfig | undefined {
+        if (this.manager.quickCreateConfig) {
+            return this.manager.quickCreateConfig();
+        }
+        throw new CreateEnvironmentNotSupported(`Quick Create Environment not supported by: ${this.id}`);
+    }
+
     public get supportsRemove(): boolean {
         return this.manager.remove !== undefined;
     }
diff --git a/src/managers/builtin/venvManager.ts b/src/managers/builtin/venvManager.ts
diff --git a/src/managers/builtin/venvUtils.ts b/src/managers/builtin/venvUtils.ts
diff --git a/src/test/features/envCommands.unit.test.ts b/src/test/features/envCommands.unit.test.ts

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ export namespace Common {`
`11`	`11`	`export const viewLogs = l10n.t('View Logs');`
`12`	`12`	`export const yes = l10n.t('Yes');`
`13`	`13`	`export const no = l10n.t('No');`
	`14`	`+ export const quickCreate = l10n.t('Quick Create');`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`export namespace Interpreter {`