Bring back feature to Run Python file in dedicated terminal (#21656)

Closes #21282
Closes #21420
Closes #21215
Reverts #21418

package.json

@@ -392,6 +392,12 @@
  "icon": "$(play)",
  "title": "%python.command.python.execInTerminalIcon.title%"
  },
+ {
+ "category": "Python",
+ "command": "python.execInDedicatedTerminal",
+ "icon": "$(play)",
+ "title": "%python.command.python.execInDedicatedTerminal.title%"
+ },
  {
  "category": "Python",
  "command": "python.debugInTerminal",
@@ -1818,6 +1824,13 @@
  "title": "%python.command.python.execInTerminalIcon.title%",
  "when": "false"
  },
+ {
+ "category": "Python",
+ "command": "python.execInDedicatedTerminal",
+ "icon": "$(play)",
+ "title": "%python.command.python.execInDedicatedTerminal.title%",
+ "when": "false"
+ },
  {
  "category": "Python",
  "command": "python.debugInTerminal",
@@ -1976,6 +1989,12 @@
  "title": "%python.command.python.execInTerminalIcon.title%",
  "when": "resourceLangId == python && !isInDiffEditor && !virtualWorkspace && shellExecutionSupported"
  },
+ {
+ "command": "python.execInDedicatedTerminal",
+ "group": "navigation@0",
+ "title": "%python.command.python.execInDedicatedTerminal.title%",
+ "when": "resourceLangId == python && !isInDiffEditor && !virtualWorkspace && shellExecutionSupported"
+ },
  {
  "command": "python.debugInTerminal",
  "group": "navigation@1",

package.nls.json

@@ -7,6 +7,7 @@
  "python.command.python.execInTerminal.title": "Run Python File in Terminal",
  "python.command.python.debugInTerminal.title": "Debug Python File",
  "python.command.python.execInTerminalIcon.title": "Run Python File",
+ "python.command.python.execInDedicatedTerminal.title": "Run Python File in Dedicated Terminal",
  "python.command.python.setInterpreter.title": "Select Interpreter",
  "python.command.python.clearWorkspaceInterpreter.title": "Clear Workspace Interpreter Setting",
  "python.command.python.viewOutput.title": "Show Output",

src/client/common/constants.ts

@@ -44,6 +44,7 @@ export namespace Commands {
  export const Enable_SourceMap_Support = 'python.enableSourceMapSupport';
  export const Exec_In_Terminal = 'python.execInTerminal';
  export const Exec_In_Terminal_Icon = 'python.execInTerminal-icon';
+ export const Exec_In_Separate_Terminal = 'python.execInDedicatedTerminal';
  export const Exec_Selection_In_Django_Shell = 'python.execSelectionInDjangoShell';
  export const Exec_Selection_In_Terminal = 'python.execSelectionInTerminal';
  export const GetSelectedInterpreterPath = 'python.interpreterPath';

src/client/common/terminal/factory.ts

@@ -3,6 +3,7 @@
 
 import { inject, injectable } from 'inversify';
 import { Uri } from 'vscode';
+import * as path from 'path';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { PythonEnvironment } from '../../pythonEnvironments/info';
@@ -23,13 +24,17 @@ export class TerminalServiceFactory implements ITerminalServiceFactory {
  ) {
  this.terminalServices = new Map<string, TerminalService>();
  }
- public getTerminalService(options: TerminalCreationOptions): ITerminalService {
+ public getTerminalService(options: TerminalCreationOptions & { newTerminalPerFile?: boolean }): ITerminalService {
  const resource = options?.resource;
  const title = options?.title;
- const terminalTitle = typeof title === 'string' && title.trim().length > 0 ? title.trim() : 'Python';
+ let terminalTitle = typeof title === 'string' && title.trim().length > 0 ? title.trim() : 'Python';
  const interpreter = options?.interpreter;
- const id = this.getTerminalId(terminalTitle, resource, interpreter);
+ const id = this.getTerminalId(terminalTitle, resource, interpreter, options.newTerminalPerFile);
  if (!this.terminalServices.has(id)) {
+ if (resource && options.newTerminalPerFile) {
+ terminalTitle = `${terminalTitle}: ${path.basename(resource.fsPath).replace('.py', '')}`;
+ }
+ options.title = terminalTitle;
  const terminalService = new TerminalService(this.serviceContainer, options);
  this.terminalServices.set(id, terminalService);
  }
@@ -46,13 +51,19 @@ export class TerminalServiceFactory implements ITerminalServiceFactory {
  title = typeof title === 'string' && title.trim().length > 0 ? title.trim() : 'Python';
  return new TerminalService(this.serviceContainer, { resource, title });
  }
- private getTerminalId(title: string, resource?: Uri, interpreter?: PythonEnvironment): string {
+ private getTerminalId(
+ title: string,
+ resource?: Uri,
+ interpreter?: PythonEnvironment,
+ newTerminalPerFile?: boolean,
+ ): string {
  if (!resource && !interpreter) {
  return title;
  }
  const workspaceFolder = this.serviceContainer
  .get<IWorkspaceService>(IWorkspaceService)
  .getWorkspaceFolder(resource || undefined);
- return `${title}:${workspaceFolder?.uri.fsPath || ''}:${interpreter?.path}`;
+ const fileId = resource && newTerminalPerFile ? resource.fsPath : '';
+ return `${title}:${workspaceFolder?.uri.fsPath || ''}:${interpreter?.path}:${fileId}`;
  }
 }

src/client/common/terminal/types.ts

@@ -97,7 +97,7 @@ export interface ITerminalServiceFactory {
  * @returns {ITerminalService}
  * @memberof ITerminalServiceFactory
  */
- getTerminalService(options: TerminalCreationOptions): ITerminalService;
+ getTerminalService(options: TerminalCreationOptions & { newTerminalPerFile?: boolean }): ITerminalService;
  createTerminalService(resource?: Uri, title?: string): ITerminalService;
 }
 

src/client/telemetry/index.ts

@@ -827,6 +827,12 @@ export interface IEventNamePropertyMapping {
  * @type {('command' | 'icon')}
  */
  trigger?: 'command' | 'icon';
+ /**
+ * Whether user chose to execute this Python file in a separate terminal or not.
+ *
+ * @type {boolean}
+ */
+ newTerminalPerFile?: boolean;
  };
  /**
  * Telemetry Event sent when user executes code against Django Shell.

src/client/terminals/codeExecution/codeExecutionManager.ts

@@ -36,25 +36,31 @@ export class CodeExecutionManager implements ICodeExecutionManager {
  }
 
  public registerCommands() {
- [Commands.Exec_In_Terminal, Commands.Exec_In_Terminal_Icon].forEach((cmd) => {
- this.disposableRegistry.push(
- this.commandManager.registerCommand(cmd as any, async (file: Resource) => {
- const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
- const interpreter = await interpreterService.getActiveInterpreter(file);
- if (!interpreter) {
- this.commandManager.executeCommand(Commands.TriggerEnvironmentSelection, file).then(noop, noop);
- return;
- }
- const trigger = cmd === Commands.Exec_In_Terminal ? 'command' : 'icon';
- await this.executeFileInTerminal(file, trigger)
- .then(() => {
- if (this.shouldTerminalFocusOnStart(file))
- this.commandManager.executeCommand('workbench.action.terminal.focus');
+ [Commands.Exec_In_Terminal, Commands.Exec_In_Terminal_Icon, Commands.Exec_In_Separate_Terminal].forEach(
+ (cmd) => {
+ this.disposableRegistry.push(
+ this.commandManager.registerCommand(cmd as any, async (file: Resource) => {
+ const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
+ const interpreter = await interpreterService.getActiveInterpreter(file);
+ if (!interpreter) {
+ this.commandManager
+ .executeCommand(Commands.TriggerEnvironmentSelection, file)
+ .then(noop, noop);
+ return;
+ }
+ const trigger = cmd === Commands.Exec_In_Terminal ? 'command' : 'icon';
+ await this.executeFileInTerminal(file, trigger, {
+ newTerminalPerFile: cmd === Commands.Exec_In_Separate_Terminal,
  })
- .catch((ex) => traceError('Failed to execute file in terminal', ex));
- }),
- );
- });
+ .then(() => {
+ if (this.shouldTerminalFocusOnStart(file))
+ this.commandManager.executeCommand('workbench.action.terminal.focus');
+ })
+ .catch((ex) => traceError('Failed to execute file in terminal', ex));
+ }),
+ );
+ },
+ );
  this.disposableRegistry.push(
  this.commandManager.registerCommand(Commands.Exec_Selection_In_Terminal as any, async (file: Resource) => {
  const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
@@ -87,8 +93,16 @@ export class CodeExecutionManager implements ICodeExecutionManager {
  ),
  );
  }
- private async executeFileInTerminal(file: Resource, trigger: 'command' | 'icon') {
- sendTelemetryEvent(EventName.EXECUTION_CODE, undefined, { scope: 'file', trigger });
+ private async executeFileInTerminal(
+ file: Resource,
+ trigger: 'command' | 'icon',
+ options?: { newTerminalPerFile: boolean },
+ ): Promise<void> {
+ sendTelemetryEvent(EventName.EXECUTION_CODE, undefined, {
+ scope: 'file',
+ trigger,
+ newTerminalPerFile: options?.newTerminalPerFile,
+ });
  const codeExecutionHelper = this.serviceContainer.get<ICodeExecutionHelper>(ICodeExecutionHelper);
  file = file instanceof Uri ? file : undefined;
  let fileToExecute = file ? file : await codeExecutionHelper.getFileToExecute();
@@ -110,7 +124,7 @@ export class CodeExecutionManager implements ICodeExecutionManager {
  }
 
  const executionService = this.serviceContainer.get<ICodeExecutionService>(ICodeExecutionService, 'standard');
- await executionService.executeFile(fileToExecute);
+ await executionService.executeFile(fileToExecute, options);
  }
 
  @captureTelemetry(EventName.EXECUTION_CODE, { scope: 'selection' }, false)

src/client/terminals/codeExecution/terminalCodeExecution.ts

@@ -10,7 +10,7 @@ import { IWorkspaceService } from '../../common/application/types';
 import '../../common/extensions';
 import { IPlatformService } from '../../common/platform/types';
 import { ITerminalService, ITerminalServiceFactory } from '../../common/terminal/types';
-import { IConfigurationService, IDisposableRegistry } from '../../common/types';
+import { IConfigurationService, IDisposableRegistry, Resource } from '../../common/types';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { buildPythonExecInfo, PythonExecInfo } from '../../pythonEnvironments/exec';
 import { ICodeExecutionService } from '../../terminals/types';
@@ -19,7 +19,6 @@ import { ICodeExecutionService } from '../../terminals/types';
 export class TerminalCodeExecutionProvider implements ICodeExecutionService {
  private hasRanOutsideCurrentDrive = false;
  protected terminalTitle!: string;
- private _terminalService!: ITerminalService;
  private replActive?: Promise<boolean>;
  constructor(
  @inject(ITerminalServiceFactory) protected readonly terminalServiceFactory: ITerminalServiceFactory,
@@ -30,35 +29,41 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
  @inject(IInterpreterService) protected readonly interpreterService: IInterpreterService,
  ) {}
 
- public async executeFile(file: Uri) {
+ public async executeFile(file: Uri, options?: { newTerminalPerFile: boolean }) {
  await this.setCwdForFileExecution(file);
  const { command, args } = await this.getExecuteFileArgs(file, [
  file.fsPath.fileToCommandArgumentForPythonExt(),
  ]);
 
- await this.getTerminalService(file).sendCommand(command, args);
+ await this.getTerminalService(file, options).sendCommand(command, args);
  }
 
  public async execute(code: string, resource?: Uri): Promise<void> {
  if (!code || code.trim().length === 0) {
  return;
  }
 
- await this.initializeRepl();
+ await this.initializeRepl(resource);
  await this.getTerminalService(resource).sendText(code);
  }
- public async initializeRepl(resource?: Uri) {
+ public async initializeRepl(resource: Resource) {
+ const terminalService = this.getTerminalService(resource);
  if (this.replActive && (await this.replActive)) {
- await this._terminalService.show();
+ await terminalService.show();
  return;
  }
  this.replActive = new Promise<boolean>(async (resolve) => {
  const replCommandArgs = await this.getExecutableInfo(resource);
- await this.getTerminalService(resource).sendCommand(replCommandArgs.command, replCommandArgs.args);
+ terminalService.sendCommand(replCommandArgs.command, replCommandArgs.args);
 
  // Give python repl time to start before we start sending text.
  setTimeout(() => resolve(true), 1000);
  });
+ this.disposables.push(
+ terminalService.onDidCloseTerminal(() => {
+ this.replActive = undefined;
+ }),
+ );
 
  await this.replActive;
  }
@@ -76,19 +81,12 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
  public async getExecuteFileArgs(resource?: Uri, executeArgs: string[] = []): Promise<PythonExecInfo> {
  return this.getExecutableInfo(resource, executeArgs);
  }
- private getTerminalService(resource?: Uri): ITerminalService {
- if (!this._terminalService) {
- this._terminalService = this.terminalServiceFactory.getTerminalService({
- resource,
- title: this.terminalTitle,
- });
- this.disposables.push(
- this._terminalService.onDidCloseTerminal(() => {
- this.replActive = undefined;
- }),
- );
- }
- return this._terminalService;
+ private getTerminalService(resource: Resource, options?: { newTerminalPerFile: boolean }): ITerminalService {
+ return this.terminalServiceFactory.getTerminalService({
+ resource,
+ title: this.terminalTitle,
+ newTerminalPerFile: options?.newTerminalPerFile,
+ });
  }
  private async setCwdForFileExecution(file: Uri) {
  const pythonSettings = this.configurationService.getSettings(file);

src/client/terminals/types.ts

@@ -8,7 +8,7 @@ export const ICodeExecutionService = Symbol('ICodeExecutionService');
 
 export interface ICodeExecutionService {
  execute(code: string, resource?: Uri): Promise<void>;
- executeFile(file: Uri): Promise<void>;
+ executeFile(file: Uri, options?: { newTerminalPerFile: boolean }): Promise<void>;
  initializeRepl(resource?: Uri): Promise<void>;
 }
 

src/test/common/terminals/factory.unit.test.ts

@@ -105,7 +105,7 @@ suite('Terminal Service Factory', () => {
  expect(notSameAsThirdInstance).to.not.equal(true, 'Instances are the same');
  });
 
- test('Ensure same terminal is returned when using resources from the same workspace', () => {
+ test('Ensure same terminal is returned when using different resources from the same workspace', () => {
  const file1A = Uri.file('1a');
  const file2A = Uri.file('2a');
  const fileB = Uri.file('b');
@@ -140,4 +140,49 @@ suite('Terminal Service Factory', () => {
  'Instances should be different for different workspaces',
  );
  });
+
+ test('When `newTerminalPerFile` is true, ensure different terminal is returned when using different resources from the same workspace', () => {
+ const file1A = Uri.file('1a');
+ const file2A = Uri.file('2a');
+ const fileB = Uri.file('b');
+ const workspaceUriA = Uri.file('A');
+ const workspaceUriB = Uri.file('B');
+ const workspaceFolderA = TypeMoq.Mock.ofType<WorkspaceFolder>();
+ workspaceFolderA.setup((w) => w.uri).returns(() => workspaceUriA);
+ const workspaceFolderB = TypeMoq.Mock.ofType<WorkspaceFolder>();
+ workspaceFolderB.setup((w) => w.uri).returns(() => workspaceUriB);
+
+ workspaceService
+ .setup((w) => w.getWorkspaceFolder(TypeMoq.It.isValue(file1A)))
+ .returns(() => workspaceFolderA.object);
+ workspaceService
+ .setup((w) => w.getWorkspaceFolder(TypeMoq.It.isValue(file2A)))
+ .returns(() => workspaceFolderA.object);
+ workspaceService
+ .setup((w) => w.getWorkspaceFolder(TypeMoq.It.isValue(fileB)))
+ .returns(() => workspaceFolderB.object);
+
+ const terminalForFile1A = factory.getTerminalService({
+ resource: file1A,
+ newTerminalPerFile: true,
+ }) as SynchronousTerminalService;
+ const terminalForFile2A = factory.getTerminalService({
+ resource: file2A,
+ newTerminalPerFile: true,
+ }) as SynchronousTerminalService;
+ const terminalForFileB = factory.getTerminalService({
+ resource: fileB,
+ newTerminalPerFile: true,
+ }) as SynchronousTerminalService;
+
+ const terminalsAreSameForWorkspaceA = terminalForFile1A.terminalService === terminalForFile2A.terminalService;
+ expect(terminalsAreSameForWorkspaceA).to.equal(false, 'Instances are the same for Workspace A');
+
+ const terminalsForWorkspaceABAreDifferent =
+ terminalForFile1A.terminalService === terminalForFileB.terminalService;
+ expect(terminalsForWorkspaceABAreDifferent).to.equal(
+ false,
+ 'Instances should be different for different workspaces',
+ );
+ });
 });