Add execution support

Author: karthiknadig

src/client/envExt/api.internal.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import { Terminal, Uri } from 'vscode';
 import { getExtension } from '../common/vscodeApis/extensionsApi';
 import {
     GetEnvironmentScope,
@@ -59,3 +60,41 @@ export async function refreshEnvironments(scope: RefreshEnvironmentsScope): Prom
     const envExtApi = await getEnvExtApi();
     return envExtApi.refreshEnvironments(scope);
 }
+
+export async function runInTerminal(
+    resource: Uri | undefined,
+    args?: string[],
+    cwd?: string | Uri,
+    show?: boolean,
+): Promise<Terminal> {
+    const envExtApi = await getEnvExtApi();
+    const env = await getEnvironment(resource);
+    const project = resource ? envExtApi.getPythonProject(resource) : undefined;
+    if (env && project && resource) {
+        return envExtApi.runInTerminal(env, {
+            cwd: cwd ?? project.uri,
+            args,
+            show,
+        });
+    }
+    throw new Error('Python environment not found');
+}
+
+export async function runInDedicatedTerminal(
+    resource: Uri | undefined,
+    args?: string[],
+    cwd?: string | Uri,
+    show?: boolean,
+): Promise<Terminal> {
+    const envExtApi = await getEnvExtApi();
+    const env = await getEnvironment(resource);
+    const project = resource ? envExtApi.getPythonProject(resource) : undefined;
+    if (env && project && resource) {
+        return envExtApi.runInDedicatedTerminal(resource, env, {
+            cwd: cwd ?? project.uri,
+            args,
+            show,
+        });
+    }
+    throw new Error('Python environment not found');
+}

src/client/envExt/api.legacy.ts

@@ -9,6 +9,8 @@ import { Architecture } from '../common/utils/platform';
 import { parseVersion } from '../pythonEnvironments/base/info/pythonVersion';
 import { PythonEnvType } from '../pythonEnvironments/base/info';
 import { traceError, traceInfo } from '../logging';
+import { reportActiveInterpreterChanged } from '../environmentApi';
+import { getWorkspaceFolder } from '../common/vscodeApis/workspaceApis';
 
 function toEnvironmentType(pythonEnv: PythonEnvironment): EnvironmentType {
     if (pythonEnv.envId.managerId.toLowerCase().endsWith('system')) {
@@ -96,8 +98,20 @@ function toLegacyType(env: PythonEnvironment): PythonEnvironmentLegacy {
     };
 }
 
+const previousEnvMap = new Map<string, PythonEnvironment | undefined>();
 export async function getActiveInterpreterLegacy(resource?: Uri): Promise<PythonEnvironmentLegacy | undefined> {
+    const api = await getEnvExtApi();
+    const uri = resource ? api.getPythonProject(resource)?.uri : undefined;
+
     const pythonEnv = await getEnvironment(resource);
+    const oldEnv = previousEnvMap.get(uri?.fsPath || '');
+    const newEnv = pythonEnv ? toLegacyType(pythonEnv) : undefined;
+    if (newEnv && oldEnv?.envId.id !== pythonEnv?.envId.id) {
+        reportActiveInterpreterChanged({
+            resource: getWorkspaceFolder(resource),
+            path: newEnv.path,
+        });
+    }
     return pythonEnv ? toLegacyType(pythonEnv) : undefined;
 }
 

src/client/interpreter/interpreterService.ts

@@ -291,6 +291,11 @@ export class InterpreterService implements Disposable, IInterpreterService {
     private async ensureEnvironmentContainsPython(pythonPath: string, workspaceFolder: WorkspaceFolder | undefined) {
         if (useEnvExtension()) {
             await ensureEnvironmentContainsPythonLegacy(pythonPath);
+            this.didChangeInterpreterEmitter.fire(workspaceFolder?.uri);
+            reportActiveInterpreterChanged({
+                path: pythonPath,
+                resource: workspaceFolder,
+            });
             return;
         }
 

src/client/terminals/codeExecution/codeExecutionManager.ts

@@ -4,7 +4,7 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
-import { Disposable, EventEmitter, Uri } from 'vscode';
+import { Disposable, EventEmitter, Terminal, Uri } from 'vscode';
 
 import { ICommandManager, IDocumentManager } from '../../common/application/types';
 import { Commands } from '../../common/constants';
@@ -22,6 +22,7 @@ import {
     triggerCreateEnvironmentCheckNonBlocking,
 } from '../../pythonEnvironments/creation/createEnvironmentTrigger';
 import { ReplType } from '../../repl/types';
+import { runInDedicatedTerminal, runInTerminal, useEnvExtension } from '../../envExt/api.internal';
 
 @injectable()
 export class CodeExecutionManager implements ICodeExecutionManager {
@@ -40,6 +41,16 @@ export class CodeExecutionManager implements ICodeExecutionManager {
                 this.disposableRegistry.push(
                     this.commandManager.registerCommand(cmd as any, async (file: Resource) => {
                         traceVerbose(`Attempting to run Python file`, file?.fsPath);
+
+                        if (useEnvExtension()) {
+                            try {
+                                await this.executeUsingExtension(file, cmd === Commands.Exec_In_Separate_Terminal);
+                            } catch (ex) {
+                                traceError('Failed to execute file in terminal', ex);
+                            }
+                            return;
+                        }
+
                         const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
                         const interpreter = await interpreterService.getActiveInterpreter(file);
                         if (!interpreter) {
@@ -101,6 +112,42 @@ export class CodeExecutionManager implements ICodeExecutionManager {
             ),
         );
     }
+
+    private async executeUsingExtension(file: Resource, dedicated: boolean): Promise<void> {
+        const codeExecutionHelper = this.serviceContainer.get<ICodeExecutionHelper>(ICodeExecutionHelper);
+        file = file instanceof Uri ? file : undefined;
+        let fileToExecute = file ? file : await codeExecutionHelper.getFileToExecute();
+        if (!fileToExecute) {
+            return;
+        }
+        const fileAfterSave = await codeExecutionHelper.saveFileIfDirty(fileToExecute);
+        if (fileAfterSave) {
+            fileToExecute = fileAfterSave;
+        }
+
+        const show = this.shouldTerminalFocusOnStart(fileToExecute);
+        let terminal: Terminal | undefined;
+        if (dedicated) {
+            terminal = await runInDedicatedTerminal(
+                fileToExecute,
+                [fileToExecute.fsPath.fileToCommandArgumentForPythonExt()],
+                undefined,
+                show,
+            );
+        } else {
+            terminal = await runInTerminal(
+                fileToExecute,
+                [fileToExecute.fsPath.fileToCommandArgumentForPythonExt()],
+                undefined,
+                show,
+            );
+        }
+
+        if (terminal) {
+            terminal.show();
+        }
+    }
+
     private async executeFileInTerminal(
         file: Resource,
         trigger: 'command' | 'icon',

src/client/testing/testController/pytest/pytestExecutionAdapter.ts

@@ -181,9 +181,13 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
             } else if (useEnvExtension()) {
                 const pythonEnv = await getEnvironment(uri);
                 if (pythonEnv) {
+                    const scriptPath = path.join(fullPluginPath, 'vscode_pytest', 'run_pytest_script.py');
+                    const runArgs = [scriptPath, ...testArgs];
+                    traceInfo(`Running pytest with arguments: ${runArgs.join(' ')} for workspace ${uri.fsPath} \r\n`);
+
                     const proc = await runInBackground(pythonEnv, {
                         cwd,
-                        args: testArgs,
+                        args: runArgs,
                         env: (mutableEnv as unknown) as { [key: string]: string },
                     });
                     runInstance?.token.onCancellationRequested(() => {