feat: add conda quick create

Author: karthiknadig

src/common/localize.ts

@@ -135,6 +135,9 @@ export namespace CondaStrings {
     export const condaCreateFailed = l10n.t('Failed to create conda environment');
     export const condaRemoveFailed = l10n.t('Failed to remove conda environment');
     export const condaExists = l10n.t('Environment already exists');
+
+    export const quickCreateCondaNoEnvRoot = l10n.t('No conda environment root found');
+    export const quickCreateCondaNoName = l10n.t('Could not generate a name for env');
 }
 
 export namespace ProjectCreatorString {

src/managers/builtin/venvUtils.ts

@@ -470,11 +470,17 @@ export async function quickCreateVenv(
     manager: EnvironmentManager,
     baseEnv: PythonEnvironment,
     venvRoot: Uri,
+    additionalPackages?: string[],
 ): Promise<PythonEnvironment | undefined> {
     const project = api.getPythonProject(venvRoot);
 
     sendTelemetryEvent(EventNames.VENV_CREATION, undefined, { creationType: 'quick' });
     const installables = await getProjectInstallable(api, project ? [project] : undefined);
+    const allPackages = [];
+    allPackages.push(...(installables?.flatMap((i) => i.args ?? []) ?? []));
+    if (additionalPackages) {
+        allPackages.push(...additionalPackages);
+    }
     return await createWithProgress(
         nativeFinder,
         api,
@@ -483,7 +489,7 @@ export async function quickCreateVenv(
         baseEnv,
         venvRoot,
         path.join(venvRoot.fsPath, '.venv'),
-        installables?.flatMap((i) => i.args ?? []),
+        allPackages.length > 0 ? allPackages : undefined,
     );
 }
 
@@ -494,7 +500,7 @@ export async function createPythonVenv(
     manager: EnvironmentManager,
     basePythons: PythonEnvironment[],
     venvRoot: Uri,
-    options: { showQuickAndCustomOptions: boolean },
+    options: { showQuickAndCustomOptions: boolean; additionalPackages?: string[] },
 ): Promise<PythonEnvironment | undefined> {
     const sortedEnvs = ensureGlobalEnv(basePythons, log);
     const project = api.getPythonProject(venvRoot);
@@ -509,6 +515,11 @@ export async function createPythonVenv(
     } else if (customize === false) {
         sendTelemetryEvent(EventNames.VENV_CREATION, undefined, { creationType: 'quick' });
         const installables = await getProjectInstallable(api, project ? [project] : undefined);
+        const allPackages = [];
+        allPackages.push(...(installables?.flatMap((i) => i.args ?? []) ?? []));
+        if (options.additionalPackages) {
+            allPackages.push(...options.additionalPackages);
+        }
         return await createWithProgress(
             nativeFinder,
             api,
@@ -517,7 +528,7 @@ export async function createPythonVenv(
             sortedEnvs[0],
             venvRoot,
             path.join(venvRoot.fsPath, '.venv'),
-            { install: installables?.flatMap((i) => i.args ?? []), uninstall: [] },
+            { install: allPackages, uninstall: [] },
         );
     } else {
         sendTelemetryEvent(EventNames.VENV_CREATION, undefined, { creationType: 'custom' });
@@ -554,8 +565,19 @@ export async function createPythonVenv(
         { showSkipOption: true, install: [] },
         project ? [project] : undefined,
     );
+    const allPackages = [];
+    allPackages.push(...(packages ?? []), ...(options.additionalPackages ?? []));
 
-    return await createWithProgress(nativeFinder, api, log, manager, basePython, venvRoot, envPath, packages);
+    return await createWithProgress(
+        nativeFinder,
+        api,
+        log,
+        manager,
+        basePython,
+        venvRoot,
+        envPath,
+        allPackages.length > 0 ? allPackages : undefined,
+    );
 }
 
 export async function removeVenv(environment: PythonEnvironment, log: LogOutputChannel): Promise<boolean> {

src/managers/conda/condaEnvManager.ts

@@ -1,6 +1,7 @@
 import * as path from 'path';
-import { Disposable, EventEmitter, LogOutputChannel, MarkdownString, ProgressLocation, Uri } from 'vscode';
+import { Disposable, EventEmitter, l10n, LogOutputChannel, MarkdownString, ProgressLocation, Uri } from 'vscode';
 import {
+    CreateEnvironmentOptions,
     CreateEnvironmentScope,
     DidChangeEnvironmentEventArgs,
     DidChangeEnvironmentsEventArgs,
@@ -12,6 +13,7 @@ import {
     PythonEnvironment,
     PythonEnvironmentApi,
     PythonProject,
+    QuickCreateConfig,
     RefreshEnvironmentsScope,
     ResolveEnvironmentContext,
     SetEnvironmentScope,
@@ -20,8 +22,11 @@ import {
     clearCondaCache,
     createCondaEnvironment,
     deleteCondaEnvironment,
+    generateName,
     getCondaForGlobal,
     getCondaForWorkspace,
+    getDefaultCondaPrefix,
+    quickCreateConda,
     refreshCondaEnvs,
     resolveCondaPath,
     setCondaForGlobal,
@@ -32,6 +37,7 @@ import { NativePythonFinder } from '../common/nativePythonFinder';
 import { createDeferred, Deferred } from '../../common/utils/deferred';
 import { withProgress } from '../../common/window.apis';
 import { CondaStrings } from '../../common/localize';
+import { showErrorMessage } from '../../common/errors/utils';
 
 export class CondaEnvManager implements EnvironmentManager, Disposable {
     private collection: PythonEnvironment[] = [];
@@ -116,29 +122,67 @@ export class CondaEnvManager implements EnvironmentManager, Disposable {
         return [];
     }
 
-    async create(context: CreateEnvironmentScope): Promise<PythonEnvironment | undefined> {
+    quickCreateConfig(): QuickCreateConfig | undefined {
+        if (!this.globalEnv) {
+            return undefined;
+        }
+
+        return {
+            description: l10n.t('Create a conda virtual environment in workspace root'),
+            detail: l10n.t('Uses Python version {0} and installs workspace dependencies.', this.globalEnv.version),
+        };
+    }
+
+    async create(
+        context: CreateEnvironmentScope,
+        options?: CreateEnvironmentOptions,
+    ): Promise<PythonEnvironment | undefined> {
         try {
-            const result = await createCondaEnvironment(
-                this.api,
-                this.log,
-                this,
-                context === 'global' ? undefined : context,
-            );
-            if (!result) {
-                return undefined;
+            let result: PythonEnvironment | undefined;
+            if (options?.quickCreate) {
+                let envRoot: string | undefined = undefined;
+                let name: string | undefined = './.conda';
+                if (context === 'global' || (Array.isArray(context) && context.length > 1)) {
+                    envRoot = await getDefaultCondaPrefix();
+                    name = await generateName(envRoot);
+                } else {
+                    const folder = this.api.getPythonProject(context instanceof Uri ? context : context[0]);
+                    envRoot = folder?.uri.fsPath;
+                }
+                if (!envRoot) {
+                    showErrorMessage(CondaStrings.quickCreateCondaNoEnvRoot);
+                    return undefined;
+                }
+                if (!name) {
+                    showErrorMessage(CondaStrings.quickCreateCondaNoName);
+                    return undefined;
+                }
+                result = await quickCreateConda(this.api, this.log, this, envRoot, name, options?.additionalPackages);
+            } else {
+                result = await createCondaEnvironment(
+                    this.api,
+                    this.log,
+                    this,
+                    context === 'global' ? undefined : context,
+                );
             }
-            this.disposablesMap.set(
-                result.envId.id,
-                new Disposable(() => {
-                    this.collection = this.collection.filter((env) => env.envId.id !== result.envId.id);
-                    Array.from(this.fsPathToEnv.entries())
-                        .filter(([, env]) => env.envId.id === result.envId.id)
-                        .forEach(([uri]) => this.fsPathToEnv.delete(uri));
-                    this.disposablesMap.delete(result.envId.id);
-                }),
-            );
-            this.collection.push(result);
-            this._onDidChangeEnvironments.fire([{ kind: EnvironmentChangeKind.add, environment: result }]);
+            if (result) {
+                this.disposablesMap.set(
+                    result.envId.id,
+                    new Disposable(() => {
+                        if (result) {
+                            this.collection = this.collection.filter((env) => env.envId.id !== result?.envId.id);
+                            Array.from(this.fsPathToEnv.entries())
+                                .filter(([, env]) => env.envId.id === result?.envId.id)
+                                .forEach(([uri]) => this.fsPathToEnv.delete(uri));
+                            this.disposablesMap.delete(result.envId.id);
+                        }
+                    }),
+                );
+                this.collection.push(result);
+                this._onDidChangeEnvironments.fire([{ kind: EnvironmentChangeKind.add, environment: result }]);
+            }
+
             return result;
         } catch (error) {
             this.log.error('Failed to create conda environment:', error);

src/managers/conda/condaUtils.ts

@@ -222,6 +222,11 @@ async function getPrefixes(): Promise<string[]> {
     return prefixes;
 }
 
+export async function getDefaultCondaPrefix(): Promise<string> {
+    const prefixes = await getPrefixes();
+    return prefixes.length > 0 ? prefixes[0] : path.join(os.homedir(), '.conda', 'envs');
+}
+
 async function getVersion(root: string): Promise<string> {
     const files = await fse.readdir(path.join(root, 'conda-meta'));
     for (let file of files) {
@@ -644,6 +649,76 @@ async function createPrefixCondaEnvironment(
     );
 }
 
+export async function generateName(fsPath: string): Promise<string | undefined> {
+    let attempts = 0;
+    while (attempts < 5) {
+        const randomStr = Math.random().toString(36).substring(2);
+        const name = `env_${randomStr}`;
+        const prefix = path.join(fsPath, name);
+        if (!(await fse.exists(prefix))) {
+            return name;
+        }
+    }
+    return undefined;
+}
+
+export async function quickCreateConda(
+    api: PythonEnvironmentApi,
+    log: LogOutputChannel,
+    manager: EnvironmentManager,
+    fsPath: string,
+    name: string,
+    additionalPackages?: string[],
+): Promise<PythonEnvironment | undefined> {
+    const prefix = path.join(fsPath, name);
+
+    return await withProgress(
+        {
+            location: ProgressLocation.Notification,
+            title: `Creating conda environment: ${name}`,
+        },
+        async () => {
+            try {
+                const bin = os.platform() === 'win32' ? 'python.exe' : 'python';
+                log.info(await runConda(['create', '--yes', '--prefix', prefix, 'python']));
+                if (additionalPackages && additionalPackages.length > 0) {
+                    log.info(await runConda(['install', '--yes', '--prefix', prefix, ...additionalPackages]));
+                }
+                const version = await getVersion(prefix);
+
+                const environment = api.createPythonEnvironmentItem(
+                    {
+                        name: path.basename(prefix),
+                        environmentPath: Uri.file(prefix),
+                        displayName: `${version} (${name})`,
+                        displayPath: prefix,
+                        description: prefix,
+                        version,
+                        execInfo: {
+                            run: { executable: path.join(prefix, bin) },
+                            activatedRun: {
+                                executable: 'conda',
+                                args: ['run', '--live-stream', '-p', prefix, 'python'],
+                            },
+                            activation: [{ executable: 'conda', args: ['activate', prefix] }],
+                            deactivation: [{ executable: 'conda', args: ['deactivate'] }],
+                        },
+                        sysPrefix: prefix,
+                        group: 'Prefix',
+                    },
+                    manager,
+                );
+                return environment;
+            } catch (e) {
+                log.error('Failed to create conda environment', e);
+                setImmediate(async () => {
+                    await showErrorMessage(CondaStrings.condaCreateFailed, log);
+                });
+            }
+        },
+    );
+}
+
 export async function deleteCondaEnvironment(environment: PythonEnvironment, log: LogOutputChannel): Promise<boolean> {
     let args = ['env', 'remove', '--yes', '--prefix', environment.environmentPath.fsPath];
     return await withProgress(