Add create environment button to requirements.txt and `pyproject.to…

…ml` files (#20879)

Closes microsoft#20812
Related microsoft#20133

package.json

@@ -18,6 +18,7 @@
  },
  "publisher": "ms-python",
  "enabledApiProposals": [
+ "contribEditorContentMenu",
  "quickPickSortByLabel",
  "envShellEvent",
  "testObserver"
@@ -41,7 +42,7 @@
  "theme": "dark"
  },
  "engines": {
- "vscode": "^1.76.0"
+ "vscode": "^1.77.0-20230309"
  },
  "keywords": [
  "python",
@@ -1688,6 +1689,18 @@
  "when": "!virtualWorkspace && shellExecutionSupported"
  }
  ],
+ "editor/content": [
+ {
+ "group": "Python",
+ "command": "python.createEnvironment",
+ "when": "resourceLangId == pip-requirements && !virtualWorkspace && shellExecutionSupported"
+ },
+ {
+ "group": "Python",
+ "command": "python.createEnvironment",
+ "when": "resourceFilename == pyproject.toml && pipInstallableToml && !virtualWorkspace && shellExecutionSupported"
+ }
+ ],
  "editor/context": [
  {
  "command": "python.execInTerminal",

package.nls.json

@@ -1,7 +1,7 @@
 {
  "python.command.python.sortImports.title": "Sort Imports",
  "python.command.python.startREPL.title": "Start REPL",
- "python.command.python.createEnvironment.title": "Create Environment",
+ "python.command.python.createEnvironment.title": "Create Environment...",
  "python.command.python.createNewFile.title": "New Python File",
  "python.command.python.createTerminal.title": "Create Terminal",
  "python.command.python.execInTerminal.title": "Run Python File in Terminal",

src/client/common/vscodeApis/workspaceApis.ts

@@ -43,3 +43,15 @@ export function onDidSaveTextDocument(
 ): vscode.Disposable {
  return vscode.workspace.onDidSaveTextDocument(listener, thisArgs, disposables);
 }
+
+export function getOpenTextDocuments(): readonly vscode.TextDocument[] {
+ return vscode.workspace.textDocuments;
+}
+
+export function onDidOpenTextDocument(handler: (doc: vscode.TextDocument) => void): vscode.Disposable {
+ return vscode.workspace.onDidOpenTextDocument(handler);
+}
+
+export function onDidChangeTextDocument(handler: (e: vscode.TextDocumentChangeEvent) => void): vscode.Disposable {
+ return vscode.workspace.onDidChangeTextDocument(handler);
+}

src/client/extensionActivation.ts

@@ -63,6 +63,7 @@ import { DynamicPythonDebugConfigurationService } from './debugger/extension/con
 import { registerCreateEnvironmentFeatures } from './pythonEnvironments/creation/createEnvApi';
 import { IInterpreterQuickPick } from './interpreter/configuration/types';
 import { registerInstallFormatterPrompt } from './providers/prompts/installFormatterPrompt';
+import { registerPyProjectTomlCreateEnvFeatures } from './pythonEnvironments/creation/pyprojectTomlCreateEnv';
 
 export async function activateComponents(
  // `ext` is passed to any extra activation funcs.
@@ -106,6 +107,7 @@ export function activateFeatures(ext: ExtensionState, _components: Components):
  );
  const pathUtils = ext.legacyIOC.serviceContainer.get<IPathUtils>(IPathUtils);
  registerCreateEnvironmentFeatures(ext.disposables, interpreterQuickPick, interpreterPathService, pathUtils);
+ registerPyProjectTomlCreateEnvFeatures(ext.disposables);
 }
 
 /// //////////////////////////

src/client/pythonEnvironments/creation/provider/venvUtils.ts

@@ -101,6 +101,11 @@ async function pickRequirementsFiles(files: string[], token?: CancellationToken)
  return undefined;
 }
 
+export function isPipInstallableToml(tomlContent: string): boolean {
+ const toml = tomlParse(tomlContent);
+ return tomlHasBuildSystem(toml);
+}
+
 export interface IPackageInstallSelection {
  installType: 'toml' | 'requirements' | 'none';
  installItem?: string;

src/client/pythonEnvironments/creation/pyprojectTomlCreateEnv.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TextDocument, TextDocumentChangeEvent } from 'vscode';
+import { IDisposableRegistry } from '../../common/types';
+import { executeCommand } from '../../common/vscodeApis/commandApis';
+import {
+ onDidOpenTextDocument,
+ onDidChangeTextDocument,
+ getOpenTextDocuments,
+} from '../../common/vscodeApis/workspaceApis';
+import { isPipInstallableToml } from './provider/venvUtils';
+
+async function setPyProjectTomlContextKey(doc: TextDocument): Promise<void> {
+ if (isPipInstallableToml(doc.getText())) {
+ await executeCommand('setContext', 'pipInstallableToml', true);
+ } else {
+ await executeCommand('setContext', 'pipInstallableToml', false);
+ }
+}
+
+export function registerPyProjectTomlCreateEnvFeatures(disposables: IDisposableRegistry): void {
+ disposables.push(
+ onDidOpenTextDocument(async (doc: TextDocument) => {
+ if (doc.fileName.endsWith('pyproject.toml')) {
+ await setPyProjectTomlContextKey(doc);
+ }
+ }),
+ onDidChangeTextDocument(async (e: TextDocumentChangeEvent) => {
+ if (e.document.fileName.endsWith('pyproject.toml')) {
+ await setPyProjectTomlContextKey(e.document);
+ }
+ }),
+ );
+
+ getOpenTextDocuments().forEach(async (doc: TextDocument) => {
+ if (doc.fileName.endsWith('pyproject.toml')) {
+ await setPyProjectTomlContextKey(doc);
+ }
+ });
+}

src/test/pythonEnvironments/creation/pyprojectTomlCreateEnv.unit.test.ts

@@ -0,0 +1,216 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as chaiAsPromised from 'chai-as-promised';
+import * as sinon from 'sinon';
+import * as typemoq from 'typemoq';
+import { assert, use as chaiUse } from 'chai';
+import { TextDocument, TextDocumentChangeEvent } from 'vscode';
+import * as cmdApis from '../../../client/common/vscodeApis/commandApis';
+import * as workspaceApis from '../../../client/common/vscodeApis/workspaceApis';
+import { IDisposableRegistry } from '../../../client/common/types';
+import { registerPyProjectTomlCreateEnvFeatures } from '../../../client/pythonEnvironments/creation/pyprojectTomlCreateEnv';
+
+chaiUse(chaiAsPromised);
+
+class FakeDisposable {
+ public dispose() {
+ // Do nothing
+ }
+}
+
+function getInstallableToml(): typemoq.IMock<TextDocument> {
+ const pyprojectTomlPath = 'pyproject.toml';
+ const pyprojectToml = typemoq.Mock.ofType<TextDocument>();
+ pyprojectToml.setup((p) => p.fileName).returns(() => pyprojectTomlPath);
+ pyprojectToml
+ .setup((p) => p.getText(typemoq.It.isAny()))
+ .returns(
+ () =>
+ '[project]\nname = "spam"\nversion = "2020.0.0"\n[build-system]\nrequires = ["setuptools ~= 58.0", "cython ~= 0.29.0"]\n[project.optional-dependencies]\ntest = ["pytest"]\ndoc = ["sphinx", "furo"]',
+ );
+ return pyprojectToml;
+}
+
+function getNonInstallableToml(): typemoq.IMock<TextDocument> {
+ const pyprojectTomlPath = 'pyproject.toml';
+ const pyprojectToml = typemoq.Mock.ofType<TextDocument>();
+ pyprojectToml.setup((p) => p.fileName).returns(() => pyprojectTomlPath);
+ pyprojectToml
+ .setup((p) => p.getText(typemoq.It.isAny()))
+ .returns(() => '[project]\nname = "spam"\nversion = "2020.0.0"\n');
+ return pyprojectToml;
+}
+
+function getSomeFile(): typemoq.IMock<TextDocument> {
+ const someFilePath = 'something.py';
+ const someFile = typemoq.Mock.ofType<TextDocument>();
+ someFile.setup((p) => p.fileName).returns(() => someFilePath);
+ someFile.setup((p) => p.getText(typemoq.It.isAny())).returns(() => 'print("Hello World")');
+ return someFile;
+}
+
+suite('PyProject.toml Create Env Features', () => {
+ let executeCommandStub: sinon.SinonStub;
+ const disposables: IDisposableRegistry = [];
+ let getOpenTextDocumentsStub: sinon.SinonStub;
+ let onDidOpenTextDocumentStub: sinon.SinonStub;
+ let onDidChangeTextDocumentStub: sinon.SinonStub;
+
+ setup(() => {
+ executeCommandStub = sinon.stub(cmdApis, 'executeCommand');
+ getOpenTextDocumentsStub = sinon.stub(workspaceApis, 'getOpenTextDocuments');
+ onDidOpenTextDocumentStub = sinon.stub(workspaceApis, 'onDidOpenTextDocument');
+ onDidChangeTextDocumentStub = sinon.stub(workspaceApis, 'onDidChangeTextDocument');
+
+ onDidOpenTextDocumentStub.returns(new FakeDisposable());
+ onDidChangeTextDocumentStub.returns(new FakeDisposable());
+ });
+
+ teardown(() => {
+ sinon.restore();
+ disposables.forEach((d) => d.dispose());
+ });
+
+ test('Installable pyproject.toml is already open in the editor on extension activate', async () => {
+ const pyprojectToml = getInstallableToml();
+ getOpenTextDocumentsStub.returns([pyprojectToml.object]);
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+
+ assert.ok(executeCommandStub.calledOnceWithExactly('setContext', 'pipInstallableToml', true));
+ });
+
+ test('Non installable pyproject.toml is already open in the editor on extension activate', async () => {
+ const pyprojectToml = getNonInstallableToml();
+ getOpenTextDocumentsStub.returns([pyprojectToml.object]);
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+
+ assert.ok(executeCommandStub.calledOnceWithExactly('setContext', 'pipInstallableToml', false));
+ });
+
+ test('Some random file open in the editor on extension activate', async () => {
+ const someFile = getSomeFile();
+ getOpenTextDocumentsStub.returns([someFile.object]);
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+
+ assert.ok(executeCommandStub.notCalled);
+ });
+
+ test('Installable pyproject.toml is opened in the editor', async () => {
+ getOpenTextDocumentsStub.returns([]);
+
+ let handler: (doc: TextDocument) => void = () => {
+ /* do nothing */
+ };
+ onDidOpenTextDocumentStub.callsFake((callback) => {
+ handler = callback;
+ return new FakeDisposable();
+ });
+
+ const pyprojectToml = getInstallableToml();
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+ handler(pyprojectToml.object);
+
+ assert.ok(executeCommandStub.calledOnceWithExactly('setContext', 'pipInstallableToml', true));
+ });
+
+ test('Non Installable pyproject.toml is opened in the editor', async () => {
+ getOpenTextDocumentsStub.returns([]);
+
+ let handler: (doc: TextDocument) => void = () => {
+ /* do nothing */
+ };
+ onDidOpenTextDocumentStub.callsFake((callback) => {
+ handler = callback;
+ return new FakeDisposable();
+ });
+
+ const pyprojectToml = getNonInstallableToml();
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+ handler(pyprojectToml.object);
+
+ assert.ok(executeCommandStub.calledOnceWithExactly('setContext', 'pipInstallableToml', false));
+ });
+
+ test('Some random file is opened in the editor', async () => {
+ getOpenTextDocumentsStub.returns([]);
+
+ let handler: (doc: TextDocument) => void = () => {
+ /* do nothing */
+ };
+ onDidOpenTextDocumentStub.callsFake((callback) => {
+ handler = callback;
+ return new FakeDisposable();
+ });
+
+ const someFile = getSomeFile();
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+ handler(someFile.object);
+
+ assert.ok(executeCommandStub.notCalled);
+ });
+
+ test('Installable pyproject.toml is changed', async () => {
+ getOpenTextDocumentsStub.returns([]);
+
+ let handler: (d: TextDocumentChangeEvent) => void = () => {
+ /* do nothing */
+ };
+ onDidChangeTextDocumentStub.callsFake((callback) => {
+ handler = callback;
+ return new FakeDisposable();
+ });
+
+ const pyprojectToml = getInstallableToml();
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+ handler({ contentChanges: [], document: pyprojectToml.object, reason: undefined });
+
+ assert.ok(executeCommandStub.calledOnceWithExactly('setContext', 'pipInstallableToml', true));
+ });
+
+ test('Non Installable pyproject.toml is changed', async () => {
+ getOpenTextDocumentsStub.returns([]);
+
+ let handler: (d: TextDocumentChangeEvent) => void = () => {
+ /* do nothing */
+ };
+ onDidChangeTextDocumentStub.callsFake((callback) => {
+ handler = callback;
+ return new FakeDisposable();
+ });
+
+ const pyprojectToml = getNonInstallableToml();
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+ handler({ contentChanges: [], document: pyprojectToml.object, reason: undefined });
+
+ assert.ok(executeCommandStub.calledOnceWithExactly('setContext', 'pipInstallableToml', false));
+ });
+
+ test('Some random file is changed', async () => {
+ getOpenTextDocumentsStub.returns([]);
+
+ let handler: (d: TextDocumentChangeEvent) => void = () => {
+ /* do nothing */
+ };
+ onDidChangeTextDocumentStub.callsFake((callback) => {
+ handler = callback;
+ return new FakeDisposable();
+ });
+
+ const someFile = getSomeFile();
+
+ registerPyProjectTomlCreateEnvFeatures(disposables);
+ handler({ contentChanges: [], document: someFile.object, reason: undefined });
+
+ assert.ok(executeCommandStub.notCalled);
+ });
+});