Trigger env creation prompt on pip install in terminal with global environment (#23247)

karthiknadig · web-flow · commit 9baedf7f68eb · 2024-04-17T10:37:58.000-07:00
Closes #23246
diff --git a/package.json b/package.json
@@ -24,7 +24,8 @@
         "quickPickItemTooltip",
         "terminalDataWriteEvent",
         "terminalExecuteCommandEvent",
-        "contribIssueReporter"
+        "contribIssueReporter",
+        "terminalShellIntegration"
     ],
     "author": {
         "name": "Microsoft Corporation"
@@ -45,7 +46,7 @@
         "theme": "dark"
     },
     "engines": {
-        "vscode": "^1.86.0"
+        "vscode": "^1.89.0-20240415"
     },
     "enableTelemetry": false,
     "keywords": [
diff --git a/src/client/common/experiments/groups.ts b/src/client/common/experiments/groups.ts
@@ -24,3 +24,9 @@ export enum EnableTestAdapterRewrite {
 export enum RecommendTensobardExtension {
     experiment = 'pythonRecommendTensorboardExt',
 }
+
+// Experiment to enable triggering venv creation when users install with `pip`
+// in a global environment
+export enum CreateEnvOnPipInstallTrigger {
+    experiment = 'pythonCreateEnvOnPipInstall',
+}
diff --git a/src/client/common/utils/localize.ts b/src/client/common/utils/localize.ts
@@ -523,5 +523,9 @@ export namespace CreateEnv {
         export const createEnvironment = l10n.t('Create');
         export const disableCheck = l10n.t('Disable');
         export const disableCheckWorkspace = l10n.t('Disable (Workspace)');
+
+        export const globalPipInstallTriggerMessage = l10n.t(
+            'You may have installed Python packages into your global environment, which can cause conflicts between package versions. Would you like to create a virtual environment to isolate your dependencies?',
+        );
     }
 }
diff --git a/src/client/common/vscodeApis/windowApis.ts b/src/client/common/vscodeApis/windowApis.ts
@@ -18,6 +18,7 @@ import {
     Disposable,
     QuickPickItemButtonEvent,
     Uri,
+    TerminalShellExecutionStartEvent,
 } from 'vscode';
 import { createDeferred, Deferred } from '../utils/async';
 
@@ -104,6 +105,10 @@ export function onDidChangeActiveTextEditor(handler: (e: TextEditor | undefined)
     return window.onDidChangeActiveTextEditor(handler);
 }
 
+export function onDidStartTerminalShellExecution(handler: (e: TerminalShellExecutionStartEvent) => void): Disposable {
+    return window.onDidStartTerminalShellExecution(handler);
+}
+
 export enum MultiStepAction {
     Back = 'Back',
     Cancel = 'Cancel',
diff --git a/src/client/pythonEnvironments/creation/common/workspaceSelection.ts b/src/client/pythonEnvironments/creation/common/workspaceSelection.ts
@@ -32,6 +32,7 @@ async function getWorkspacesForQuickPick(workspaces: readonly WorkspaceFolder[])
 export interface PickWorkspaceFolderOptions {
     allowMultiSelect?: boolean;
     token?: CancellationToken;
+    preSelectedWorkspace?: WorkspaceFolder;
 }
 
 export async function pickWorkspaceFolder(
@@ -52,6 +53,15 @@ export async function pickWorkspaceFolder(
         return undefined;
     }
 
+    if (options?.preSelectedWorkspace) {
+        if (context === MultiStepAction.Back) {
+            // In this case there is no Quick Pick shown, should just go to previous
+            throw MultiStepAction.Back;
+        }
+
+        return options.preSelectedWorkspace;
+    }
+
     if (workspaces.length === 1) {
         if (context === MultiStepAction.Back) {
             // In this case there is no Quick Pick shown, should just go to previous
diff --git a/src/client/pythonEnvironments/creation/createEnvApi.ts b/src/client/pythonEnvironments/creation/createEnvApi.ts
@@ -20,6 +20,7 @@ import {
 } from './proposed.createEnvApis';
 import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
+import { CreateEnvironmentOptionsInternal } from './types';
 
 class CreateEnvironmentProviders {
     private _createEnvProviders: CreateEnvironmentProvider[] = [];
@@ -64,7 +65,9 @@ export function registerCreateEnvironmentFeatures(
     disposables.push(
         registerCommand(
             Commands.Create_Environment,
-            (options?: CreateEnvironmentOptions): Promise<CreateEnvironmentResult | undefined> => {
+            (
+                options?: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal,
+            ): Promise<CreateEnvironmentResult | undefined> => {
                 const providers = _createEnvironmentProviders.getAll();
                 return handleCreateEnvironmentCommand(providers, options);
             },
diff --git a/src/client/pythonEnvironments/creation/createEnvironment.ts b/src/client/pythonEnvironments/creation/createEnvironment.ts
@@ -17,6 +17,7 @@ import {
     EnvironmentWillCreateEvent,
     EnvironmentDidCreateEvent,
 } from './proposed.createEnvApis';
+import { CreateEnvironmentOptionsInternal } from './types';
 
 const onCreateEnvironmentStartedEvent = new EventEmitter<EnvironmentWillCreateEvent>();
 const onCreateEnvironmentExitedEvent = new EventEmitter<EnvironmentDidCreateEvent>();
@@ -55,7 +56,7 @@ export function getCreationEvents(): {
 
 async function createEnvironment(
     provider: CreateEnvironmentProvider,
-    options: CreateEnvironmentOptions,
+    options: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal,
 ): Promise<CreateEnvironmentResult | undefined> {
     let result: CreateEnvironmentResult | undefined;
     let err: Error | undefined;
@@ -83,14 +84,21 @@ interface CreateEnvironmentProviderQuickPickItem extends QuickPickItem {
 
 async function showCreateEnvironmentQuickPick(
     providers: readonly CreateEnvironmentProvider[],
-    options?: CreateEnvironmentOptions,
+    options?: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal,
 ): Promise<CreateEnvironmentProvider | undefined> {
     const items: CreateEnvironmentProviderQuickPickItem[] = providers.map((p) => ({
         label: p.name,
         description: p.description,
         id: p.id,
     }));
 
+    if (options?.providerId) {
+        const provider = providers.find((p) => p.id === options.providerId);
+        if (provider) {
+            return provider;
+        }
+    }
+
     let selectedItem: CreateEnvironmentProviderQuickPickItem | CreateEnvironmentProviderQuickPickItem[] | undefined;
 
     if (options?.showBackButton) {
@@ -119,7 +127,9 @@ async function showCreateEnvironmentQuickPick(
     return undefined;
 }
 
-function getOptionsWithDefaults(options?: CreateEnvironmentOptions): CreateEnvironmentOptions {
+function getOptionsWithDefaults(
+    options?: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal,
+): CreateEnvironmentOptions & CreateEnvironmentOptionsInternal {
     return {
         installPackages: true,
         ignoreSourceControl: true,
@@ -131,7 +141,7 @@ function getOptionsWithDefaults(options?: CreateEnvironmentOptions): CreateEnvir
 
 export async function handleCreateEnvironmentCommand(
     providers: readonly CreateEnvironmentProvider[],
-    options?: CreateEnvironmentOptions,
+    options?: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal,
 ): Promise<CreateEnvironmentResult | undefined> {
     const optionsWithDefaults = getOptionsWithDefaults(options);
     let selectedProvider: CreateEnvironmentProvider | undefined;
diff --git a/src/client/pythonEnvironments/creation/globalPipInTerminalTrigger.ts b/src/client/pythonEnvironments/creation/globalPipInTerminalTrigger.ts
@@ -0,0 +1,81 @@
+import { Disposable, TerminalShellExecutionStartEvent } from 'vscode';
+import { CreateEnvOnPipInstallTrigger } from '../../common/experiments/groups';
+import { inExperiment } from '../common/externalDependencies';
+import {
+    disableCreateEnvironmentTrigger,
+    disableWorkspaceCreateEnvironmentTrigger,
+    isGlobalPythonSelected,
+    shouldPromptToCreateEnv,
+} from './common/createEnvTriggerUtils';
+import { getWorkspaceFolder, getWorkspaceFolders } from '../../common/vscodeApis/workspaceApis';
+import { CreateEnv } from '../../common/utils/localize';
+import { traceError, traceInfo } from '../../logging';
+import { executeCommand } from '../../common/vscodeApis/commandApis';
+import { Commands, PVSC_EXTENSION_ID } from '../../common/constants';
+import { CreateEnvironmentResult } from './proposed.createEnvApis';
+import { onDidStartTerminalShellExecution, showWarningMessage } from '../../common/vscodeApis/windowApis';
+import { sendTelemetryEvent } from '../../telemetry';
+import { EventName } from '../../telemetry/constants';
+
+export function registerTriggerForPipInTerminal(disposables: Disposable[]): void {
+    if (!shouldPromptToCreateEnv() || !inExperiment(CreateEnvOnPipInstallTrigger.experiment)) {
+        return;
+    }
+
+    const folders = getWorkspaceFolders();
+    if (!folders || folders.length === 0) {
+        return;
+    }
+
+    const createEnvironmentTriggered: Map<string, boolean> = new Map();
+    folders.forEach((workspaceFolder) => {
+        createEnvironmentTriggered.set(workspaceFolder.uri.fsPath, false);
+    });
+
+    disposables.push(
+        onDidStartTerminalShellExecution(async (e: TerminalShellExecutionStartEvent) => {
+            const workspaceFolder = getWorkspaceFolder(e.shellIntegration.cwd);
+            if (
+                workspaceFolder &&
+                !createEnvironmentTriggered.get(workspaceFolder.uri.fsPath) &&
+                (await isGlobalPythonSelected(workspaceFolder))
+            ) {
+                if (e.execution.commandLine.isTrusted && e.execution.commandLine.value.startsWith('pip install')) {
+                    createEnvironmentTriggered.set(workspaceFolder.uri.fsPath, true);
+                    sendTelemetryEvent(EventName.ENVIRONMENT_TERMINAL_GLOBAL_PIP);
+                    const selection = await showWarningMessage(
+                        CreateEnv.Trigger.globalPipInstallTriggerMessage,
+                        CreateEnv.Trigger.createEnvironment,
+                        CreateEnv.Trigger.disableCheckWorkspace,
+                        CreateEnv.Trigger.disableCheck,
+                    );
+                    if (selection === CreateEnv.Trigger.createEnvironment) {
+                        try {
+                            const result: CreateEnvironmentResult = await executeCommand(Commands.Create_Environment, {
+                                workspaceFolder,
+                                providerId: `${PVSC_EXTENSION_ID}:venv`,
+                            });
+                            if (result.path) {
+                                traceInfo('CreateEnv Trigger - Environment created: ', result.path);
+                                traceInfo(
+                                    `CreateEnv Trigger - Running: ${
+                                        result.path
+                                    } -m ${e.execution.commandLine.value.trim()}`,
+                                );
+                                e.shellIntegration.executeCommand(
+                                    `${result.path} -m ${e.execution.commandLine.value}`.trim(),
+                                );
+                            }
+                        } catch (error) {
+                            traceError('CreateEnv Trigger - Error while creating environment: ', error);
+                        }
+                    } else if (selection === CreateEnv.Trigger.disableCheck) {
+                        disableCreateEnvironmentTrigger();
+                    } else if (selection === CreateEnv.Trigger.disableCheckWorkspace) {
+                        disableWorkspaceCreateEnvironmentTrigger();
+                    }
+                }
+            }
+        }),
+    );
+}
diff --git a/src/client/pythonEnvironments/creation/provider/venvCreationProvider.ts b/src/client/pythonEnvironments/creation/provider/venvCreationProvider.ts
@@ -9,7 +9,7 @@ import { execObservable } from '../../../common/process/rawProcessApis';
 import { createDeferred } from '../../../common/utils/async';
 import { Common, CreateEnv } from '../../../common/utils/localize';
 import { traceError, traceInfo, traceLog, traceVerbose } from '../../../logging';
-import { CreateEnvironmentProgress } from '../types';
+import { CreateEnvironmentOptionsInternal, CreateEnvironmentProgress } from '../types';
 import { pickWorkspaceFolder } from '../common/workspaceSelection';
 import { IInterpreterQuickPick } from '../../../interpreter/configuration/types';
 import { EnvironmentType, PythonEnvironment } from '../../info';
@@ -152,13 +152,18 @@ async function createVenv(
 export class VenvCreationProvider implements CreateEnvironmentProvider {
     constructor(private readonly interpreterQuickPick: IInterpreterQuickPick) {}
 
-    public async createEnvironment(options?: CreateEnvironmentOptions): Promise<CreateEnvironmentResult | undefined> {
+    public async createEnvironment(
+        options?: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal,
+    ): Promise<CreateEnvironmentResult | undefined> {
         let workspace: WorkspaceFolder | undefined;
         const workspaceStep = new MultiStepNode(
             undefined,
             async (context?: MultiStepAction) => {
                 try {
-                    workspace = (await pickWorkspaceFolder(undefined, context)) as WorkspaceFolder | undefined;
+                    workspace = (await pickWorkspaceFolder(
+                        { preSelectedWorkspace: options?.workspaceFolder },
+                        context,
+                    )) as WorkspaceFolder | undefined;
                 } catch (ex) {
                     if (ex === MultiStepAction.Back || ex === MultiStepAction.Cancel) {
                         return ex;
diff --git a/src/client/pythonEnvironments/creation/registrations.ts b/src/client/pythonEnvironments/creation/registrations.ts
@@ -6,6 +6,7 @@ import { IInterpreterQuickPick } from '../../interpreter/configuration/types';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { registerCreateEnvironmentFeatures } from './createEnvApi';
 import { registerCreateEnvironmentButtonFeatures } from './createEnvButtonContext';
+import { registerTriggerForPipInTerminal } from './globalPipInTerminalTrigger';
 import { registerInstalledPackagesDiagnosticsProvider } from './installedPackagesDiagnostic';
 import { registerPyProjectTomlFeatures } from './pyProjectTomlContext';
 
@@ -20,4 +21,5 @@ export function registerAllCreateEnvironmentFeatures(
     registerCreateEnvironmentButtonFeatures(disposables);
     registerPyProjectTomlFeatures(disposables);
     registerInstalledPackagesDiagnosticsProvider(disposables, interpreterService);
+    registerTriggerForPipInTerminal(disposables);
 }
diff --git a/src/client/pythonEnvironments/creation/types.ts b/src/client/pythonEnvironments/creation/types.ts
@@ -1,6 +1,11 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License
 
-import { Progress } from 'vscode';
+import { Progress, WorkspaceFolder } from 'vscode';
 
 export interface CreateEnvironmentProgress extends Progress<{ message?: string; increment?: number }> {}
+
+export interface CreateEnvironmentOptionsInternal {
+    workspaceFolder?: WorkspaceFolder;
+    providerId?: string;
+}
diff --git a/src/client/telemetry/constants.ts b/src/client/telemetry/constants.ts
@@ -112,6 +112,7 @@ export enum EventName {
 
     ENVIRONMENT_CHECK_TRIGGER = 'ENVIRONMENT.CHECK.TRIGGER',
     ENVIRONMENT_CHECK_RESULT = 'ENVIRONMENT.CHECK.RESULT',
+    ENVIRONMENT_TERMINAL_GLOBAL_PIP = 'ENVIRONMENT.TERMINAL.GLOBAL_PIP',
 }
 
 export enum PlatformErrors {
diff --git a/src/client/telemetry/index.ts b/src/client/telemetry/index.ts
@@ -2030,6 +2030,13 @@ export interface IEventNamePropertyMapping {
     [EventName.ENVIRONMENT_CHECK_RESULT]: {
         result: 'criteria-met' | 'criteria-not-met' | 'already-ran' | 'turned-off' | 'no-uri';
     };
+    /**
+     * Telemetry event sent when `pip install` was called from a global env in a shell where shell inegration is supported.
+     */
+    /* __GDPR__
+       "environment.terminal.global_pip" : { "owner": "karthiknadig" }
+     */
+    [EventName.ENVIRONMENT_TERMINAL_GLOBAL_PIP]: never | undefined;
     /* __GDPR__
             "query-expfeature" : {
                 "owner": "luabud",
diff --git a/src/test/pythonEnvironments/creation/globalPipInTerminalTrigger.unit.test.ts b/src/test/pythonEnvironments/creation/globalPipInTerminalTrigger.unit.test.ts
diff --git a/types/vscode.proposed.terminalShellIntegration.d.ts b/types/vscode.proposed.terminalShellIntegration.d.ts

Original file line number	Diff line number	Diff line change
`@@ -523,5 +523,9 @@ export namespace CreateEnv {`
`523`	`523`	`export const createEnvironment = l10n.t('Create');`
`524`	`524`	`export const disableCheck = l10n.t('Disable');`
`525`	`525`	`export const disableCheckWorkspace = l10n.t('Disable (Workspace)');`
	`526`	`+`
	`527`	`+ export const globalPipInstallTriggerMessage = l10n.t(`
	`528`	`+ 'You may have installed Python packages into your global environment, which can cause conflicts between package versions. Would you like to create a virtual environment to isolate your dependencies?',`
	`529`	`+ );`
`526`	`530`	`}`
`527`	`531`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,6 +112,7 @@ export enum EventName {`
`112`	`112`
`113`	`113`	`ENVIRONMENT_CHECK_TRIGGER = 'ENVIRONMENT.CHECK.TRIGGER',`
`114`	`114`	`ENVIRONMENT_CHECK_RESULT = 'ENVIRONMENT.CHECK.RESULT',`
	`115`	`+ ENVIRONMENT_TERMINAL_GLOBAL_PIP = 'ENVIRONMENT.TERMINAL.GLOBAL_PIP',`
`115`	`116`	`}`
`116`	`117`
`117`	`118`	`export enum PlatformErrors {`