Merge remote-tracking branch 'Parent/main' into Current

Author: NikolaRHristov

.prettierignore

@@ -0,0 +1,3 @@
+# Ignore the pythonEnvironments/ folder because we use ESLint there instead
+src/client/pythonEnvironments/*
+src/test/pythonEnvironments/*

.prettierrc.js

@@ -0,0 +1,21 @@
+module.exports = {
+    singleQuote: true,
+    printWidth: 120,
+    tabWidth: 4,
+    endOfLine: 'auto',
+    trailingComma: 'none',
+    overrides: [
+        {
+            files: ['*.yml', '*.yaml'],
+            options: {
+                tabWidth: 2
+            }
+        },
+        {
+            files: ['**/datascience/serviceRegistry.ts'],
+            options: {
+                printWidth: 240
+            }
+        }
+    ]
+};

package.json

@@ -1,12 +1,17 @@
 {
-	"dependencies": {},
-	"description": "VS Code module for installing python packages",
-	"devDependencies": {},
-	"name": "@vscode/python-installer",
-	"scripts": {
-		"compile": "tsc -p ./",
-		"compilewatch": "tsc -watch -p ./",
-		"download-api": "vscode-dts dev",
-		"postdownload-api": "vscode-dts main"
-	}
+    "name": "@vscode/python-installer",
+    "version": "0.1.0",
+    "description": "VS Code module for installing python packages",
+    "scripts": {
+        "compile": "tsc -p ./",
+        "compilewatch": "tsc -watch -p ./",
+        "download-api": "vscode-dts dev",
+        "postdownload-api": "vscode-dts main"
+    },
+    "author": "Visual Studio Code Team",
+    "license": "MIT",
+    "dependencies": {
+    },
+    "devDependencies": {
+    }
 }

src/channelManager.ts

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { IInterpreterService } from '../../interpreter/contracts';
+import { IServiceContainer } from '../../ioc/types';
+import { EnvironmentType } from '../../pythonEnvironments/info';
+import { IApplicationShell } from '../application/types';
+import { IPlatformService } from '../platform/types';
+import { Product } from '../types';
+import { Installer } from '../utils/localize';
+import { isResource } from '../utils/misc';
+import { ProductNames } from './productNames';
+import { IInstallationChannelManager, IModuleInstaller, InterpreterUri } from './types';
+
+@injectable()
+export class InstallationChannelManager implements IInstallationChannelManager {
+    constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {}
+
+    public async getInstallationChannel(
+        product: Product,
+        resource?: InterpreterUri,
+    ): Promise<IModuleInstaller | undefined> {
+        const channels = await this.getInstallationChannels(resource);
+        if (channels.length === 1) {
+            return channels[0];
+        }
+
+        const productName = ProductNames.get(product)!;
+        const appShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
+        if (channels.length === 0) {
+            await this.showNoInstallersMessage(isResource(resource) ? resource : undefined);
+            return;
+        }
+
+        const placeHolder = `Select an option to install ${productName}`;
+        const options = channels.map((installer) => {
+            return {
+                label: `Install using ${installer.displayName}`,
+                description: '',
+                installer,
+            };
+        });
+        const selection = await appShell.showQuickPick<typeof options[0]>(options, {
+            matchOnDescription: true,
+            matchOnDetail: true,
+            placeHolder,
+        });
+        return selection ? selection.installer : undefined;
+    }
+
+    public async getInstallationChannels(resource?: InterpreterUri): Promise<IModuleInstaller[]> {
+        const installers = this.serviceContainer.getAll<IModuleInstaller>(IModuleInstaller);
+        const supportedInstallers: IModuleInstaller[] = [];
+        if (installers.length === 0) {
+            return [];
+        }
+        // group by priority and pick supported from the highest priority
+        installers.sort((a, b) => b.priority - a.priority);
+        let currentPri = installers[0].priority;
+        for (const mi of installers) {
+            if (mi.priority !== currentPri) {
+                if (supportedInstallers.length > 0) {
+                    break; // return highest priority supported installers
+                }
+                // If none supported, try next priority group
+                currentPri = mi.priority;
+            }
+            if (await mi.isSupported(resource)) {
+                supportedInstallers.push(mi);
+            }
+        }
+        return supportedInstallers;
+    }
+
+    public async showNoInstallersMessage(resource?: Uri): Promise<void> {
+        const interpreters = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
+        const interpreter = await interpreters.getActiveInterpreter(resource);
+        if (!interpreter) {
+            return; // Handled in the Python installation check.
+        }
+
+        const appShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
+        const search = 'Search for help';
+        let result: string | undefined;
+        if (interpreter.envType === EnvironmentType.Conda) {
+            result = await appShell.showErrorMessage(Installer.noCondaOrPipInstaller(), Installer.searchForHelp());
+        } else {
+            result = await appShell.showErrorMessage(Installer.noPipInstaller(), Installer.searchForHelp());
+        }
+        if (result === search) {
+            const platform = this.serviceContainer.get<IPlatformService>(IPlatformService);
+            const osName = platform.isWindows ? 'Windows' : platform.isMac ? 'MacOS' : 'Linux';
+            appShell.openUrl(
+                `https://www.bing.com/search?q=Install Pip ${osName} ${
+                    interpreter.envType === EnvironmentType.Conda ? 'Conda' : ''
+                }`,
+            );
+        }
+    }
+}

src/condaInstaller.ts

@@ -0,0 +1,133 @@
+/* eslint-disable class-methods-use-this */
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { ICondaService, IComponentAdapter } from '../../interpreter/contracts';
+import { IServiceContainer } from '../../ioc/types';
+import { ModuleInstallerType } from '../../pythonEnvironments/info';
+import { ExecutionInfo, IConfigurationService, Product } from '../types';
+import { isResource } from '../utils/misc';
+import { ModuleInstaller, translateProductToModule } from './moduleInstaller';
+import { InterpreterUri, ModuleInstallFlags } from './types';
+
+/**
+ * A Python module installer for a conda environment.
+ */
+@injectable()
+export class CondaInstaller extends ModuleInstaller {
+    public _isCondaAvailable: boolean | undefined;
+
+    // Unfortunately inversify requires the number of args in constructor to be explictly
+    // specified as more than its base class. So we need the constructor.
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
+        super(serviceContainer);
+    }
+
+    public get name(): string {
+        return 'Conda';
+    }
+
+    public get displayName(): string {
+        return 'Conda';
+    }
+
+    public get type(): ModuleInstallerType {
+        return ModuleInstallerType.Conda;
+    }
+
+    public get priority(): number {
+        return 0;
+    }
+
+    /**
+     * Checks whether we can use Conda as module installer for a given resource.
+     * We need to perform two checks:
+     * 1. Ensure we have conda.
+     * 2. Check if the current environment is a conda environment.
+     * @param {InterpreterUri} [resource=] Resource used to identify the workspace.
+     * @returns {Promise<boolean>} Whether conda is supported as a module installer or not.
+     */
+    public async isSupported(resource?: InterpreterUri): Promise<boolean> {
+        if (this._isCondaAvailable === false) {
+            return false;
+        }
+        const condaLocator = this.serviceContainer.get<ICondaService>(ICondaService);
+        this._isCondaAvailable = await condaLocator.isCondaAvailable();
+        if (!this._isCondaAvailable) {
+            return false;
+        }
+        // Now we need to check if the current environment is a conda environment or not.
+        return this.isCurrentEnvironmentACondaEnvironment(resource);
+    }
+
+    /**
+     * Return the commandline args needed to install the module.
+     */
+    protected async getExecutionInfo(
+        moduleName: string,
+        resource?: InterpreterUri,
+        flags: ModuleInstallFlags = 0,
+    ): Promise<ExecutionInfo> {
+        const condaService = this.serviceContainer.get<ICondaService>(ICondaService);
+        const condaFile = await condaService.getCondaFile();
+
+        const pythonPath = isResource(resource)
+            ? this.serviceContainer.get<IConfigurationService>(IConfigurationService).getSettings(resource).pythonPath
+            : resource.path;
+        const condaLocatorService = this.serviceContainer.get<IComponentAdapter>(IComponentAdapter);
+        const info = await condaLocatorService.getCondaEnvironment(pythonPath);
+        const args = [flags & ModuleInstallFlags.upgrade ? 'update' : 'install'];
+
+        // Found that using conda-forge is best at packages like tensorboard & ipykernel which seem to get updated first on conda-forge
+        // https://github.com/microsoft/vscode-jupyter/issues/7787 & https://github.com/microsoft/vscode-python/issues/17628
+        // Do this just for the datascience packages.
+        if (
+            [
+                Product.tensorboard,
+                Product.ipykernel,
+                Product.pandas,
+                Product.nbconvert,
+                Product.jupyter,
+                Product.notebook,
+            ]
+                .map(translateProductToModule)
+                .includes(moduleName)
+        ) {
+            args.push('-c', 'conda-forge');
+        }
+        if (info && info.name) {
+            // If we have the name of the conda environment, then use that.
+            args.push('--name');
+            args.push(info.name.toCommandArgument());
+        } else if (info && info.path) {
+            // Else provide the full path to the environment path.
+            args.push('--prefix');
+            args.push(info.path.fileToCommandArgument());
+        }
+        if (flags & ModuleInstallFlags.updateDependencies) {
+            args.push('--update-deps');
+        }
+        if (flags & ModuleInstallFlags.reInstall) {
+            args.push('--force-reinstall');
+        }
+        args.push(moduleName);
+        args.push('-y');
+        return {
+            args,
+            execPath: condaFile,
+        };
+    }
+
+    /**
+     * Is the provided interprter a conda environment
+     */
+    private async isCurrentEnvironmentACondaEnvironment(resource?: InterpreterUri): Promise<boolean> {
+        const condaService = this.serviceContainer.get<IComponentAdapter>(IComponentAdapter);
+        const pythonPath = isResource(resource)
+            ? this.serviceContainer.get<IConfigurationService>(IConfigurationService).getSettings(resource).pythonPath
+            : resource.path;
+        return condaService.isCondaEnvironment(pythonPath);
+    }
+}

src/extensionBuildInstaller.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { traceDecoratorError, traceLog } from '../../logging';
+import { IApplicationShell, ICommandManager } from '../application/types';
+import { Octicons, PVSC_EXTENSION_ID } from '../constants';
+import { IFileSystem } from '../platform/types';
+import { IFileDownloader } from '../types';
+import { ExtensionChannels } from '../utils/localize';
+import { IExtensionBuildInstaller } from './types';
+
+export const developmentBuildUri = 'https://pvsc.blob.core.windows.net/extension-builds/ms-python-insiders.vsix';
+export const vsixFileExtension = '.vsix';
+
+@injectable()
+export class StableBuildInstaller implements IExtensionBuildInstaller {
+    constructor(
+        @inject(ICommandManager) private readonly cmdManager: ICommandManager,
+        @inject(IApplicationShell) private readonly appShell: IApplicationShell,
+    ) {}
+
+    @traceDecoratorError('Installing stable build of extension failed')
+    public async install(): Promise<void> {
+        traceLog(ExtensionChannels.installingStableMessage());
+        await this.appShell.withProgressCustomIcon(Octicons.Installing, async (progress) => {
+            progress.report({ message: ExtensionChannels.installingStableMessage() });
+            return this.cmdManager.executeCommand('workbench.extensions.installExtension', PVSC_EXTENSION_ID, {
+                installOnlyNewlyAddedFromExtensionPackVSIX: true,
+            });
+        });
+        traceLog(ExtensionChannels.installationCompleteMessage());
+    }
+}
+
+@injectable()
+export class InsidersBuildInstaller implements IExtensionBuildInstaller {
+    constructor(
+        @inject(IFileDownloader) private readonly fileDownloader: IFileDownloader,
+        @inject(IFileSystem) private readonly fs: IFileSystem,
+        @inject(ICommandManager) private readonly cmdManager: ICommandManager,
+        @inject(IApplicationShell) private readonly appShell: IApplicationShell,
+    ) {}
+
+    @traceDecoratorError('Installing insiders build of extension failed')
+    public async install(): Promise<void> {
+        const vsixFilePath = await this.downloadInsiders();
+        traceLog(ExtensionChannels.installingInsidersMessage());
+        await this.appShell.withProgressCustomIcon(Octicons.Installing, async (progress) => {
+            progress.report({ message: ExtensionChannels.installingInsidersMessage() });
+            return this.cmdManager.executeCommand('workbench.extensions.installExtension', Uri.file(vsixFilePath), {
+                installOnlyNewlyAddedFromExtensionPackVSIX: true,
+            });
+        });
+        traceLog(ExtensionChannels.installationCompleteMessage());
+        await this.fs.deleteFile(vsixFilePath);
+    }
+
+    @traceDecoratorError('Downloading insiders build of extension failed')
+    public async downloadInsiders(): Promise<string> {
+        traceLog(ExtensionChannels.startingDownloadOutputMessage());
+        const downloadOptions = {
+            extension: vsixFileExtension,
+            progressMessagePrefix: ExtensionChannels.downloadingInsidersMessage(),
+        };
+        return this.fileDownloader.downloadFile(developmentBuildUri, downloadOptions).then((file) => {
+            traceLog(ExtensionChannels.downloadCompletedOutputMessage());
+            return file;
+        });
+    }
+}