Support pipenv

package.json

@@ -1086,6 +1086,19 @@
                     "description": "Path to folder with a list of Virtual Environments (e.g. ~/.pyenv, ~/Envs, ~/.virtualenvs).",
                     "scope": "resource"
                 },
+                "python.venvFolders": {
+                    "type": "array",
+                    "default": [
+                        "envs",
+                        ".pyenv",
+                        ".direnv"
+                    ],
+                    "description": "Folders to look into for virtual environments.",
+                    "scope": "resource",
+                    "items": {
+                        "type": "string"
+                    }
+                },
                 "python.envFile": {
                     "type": "string",
                     "description": "Absolute path to a file containing environment variable definitions.",
@@ -1860,4 +1873,4 @@
         "publisherDisplayName": "Microsoft",
         "publisherId": "998b010b-e2af-44a5-a6cd-0b5fd3b9b6f8"
     }
-}
+}

src/client/common/application/types.ts

@@ -413,8 +413,6 @@ export interface IWorkspaceService {
      * ~~The folder that is open in the editor. `undefined` when no folder
      * has been opened.~~
      *
-     * @deprecated Use [`workspaceFolders`](#workspace.workspaceFolders) instead.
-     *
      * @readonly
      */
     readonly rootPath: string | undefined;

src/client/common/application/workspace.ts

@@ -12,7 +12,7 @@ export class WorkspaceService implements IWorkspaceService {
         return vscode.workspace.onDidChangeConfiguration;
     }
     public get rootPath(): string | undefined {
-        return vscode.workspace.rootPath;
+        return Array.isArray(vscode.workspace.workspaceFolders) ? vscode.workspace.workspaceFolders[0].uri.fsPath : undefined;
     }
     public get workspaceFolders(): vscode.WorkspaceFolder[] | undefined {
         return vscode.workspace.workspaceFolders;

src/client/common/configSettings.ts

@@ -32,6 +32,7 @@ export class PythonSettings extends EventEmitter implements IPythonSettings {
     public envFile: string;
     public disablePromptForFeatures: string[];
     public venvPath: string;
+    public venvFolders: string[];
     public devOptions: string[];
     public linting: ILintingSettings;
     public formatting: IFormattingSettings;
@@ -106,6 +107,7 @@ export class PythonSettings extends EventEmitter implements IPythonSettings {
         this.pythonPath = getAbsolutePath(this.pythonPath, workspaceRoot);
         // tslint:disable-next-line:no-backbone-get-set-outside-model no-non-null-assertion
         this.venvPath = systemVariables.resolveAny(pythonSettings.get<string>('venvPath'))!;
+        this.venvFolders = systemVariables.resolveAny(pythonSettings.get<string[]>('venvFolders'))!;
         // tslint:disable-next-line:no-backbone-get-set-outside-model no-non-null-assertion
         this.jediPath = systemVariables.resolveAny(pythonSettings.get<string>('jediPath'))!;
         if (typeof this.jediPath === 'string' && this.jediPath.length > 0) {

src/client/common/installer/channelManager.ts

@@ -41,9 +41,22 @@ export class InstallationChannelManager implements IInstallationChannelManager {
     }
 
     public async getInstallationChannels(resource?: Uri): Promise<IModuleInstaller[]> {
-        const installers = this.serviceContainer.getAll<IModuleInstaller>(IModuleInstaller);
+        let 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 = 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);
             }

src/client/common/installer/condaInstaller.ts

@@ -15,6 +15,9 @@ export class CondaInstaller extends ModuleInstaller implements IModuleInstaller
     public get displayName() {
         return 'Conda';
     }
+    public get priority(): number {
+        return 0;
+    }
     constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
         super(serviceContainer);
     }

src/client/common/installer/pipEnvInstaller.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { IInterpreterLocatorService, PIPENV_SERVICE } from '../../interpreter/contracts';
+import { IServiceContainer } from '../../ioc/types';
+import { ITerminalServiceFactory } from '../terminal/types';
+import { IModuleInstaller } from './types';
+
+const pipenvName = 'pipenv';
+
+@injectable()
+export class PipEnvInstaller implements IModuleInstaller {
+    private readonly pipenv: IInterpreterLocatorService;
+
+    public get displayName() {
+        return pipenvName;
+    }
+    public get priority(): number {
+        return 10;
+    }
+
+    constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
+        this.pipenv = this.serviceContainer.get<IInterpreterLocatorService>(IInterpreterLocatorService, PIPENV_SERVICE);
+    }
+
+    public installModule(name: string): Promise<void> {
+        const terminalService = this.serviceContainer.get<ITerminalServiceFactory>(ITerminalServiceFactory).getTerminalService();
+        return terminalService.sendCommand(pipenvName, ['install', name]);
+    }
+
+    public async isSupported(resource?: Uri): Promise<boolean> {
+        const interpreters = await this.pipenv.getInterpreters(resource);
+        return interpreters && interpreters.length > 0;
+    }
+}

src/client/common/installer/pipInstaller.ts

@@ -14,14 +14,17 @@ export class PipInstaller extends ModuleInstaller implements IModuleInstaller {
     public get displayName() {
         return 'Pip';
     }
-    constructor( @inject(IServiceContainer) serviceContainer: IServiceContainer) {
+    public get priority(): number {
+        return 0;
+    }
+    constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
         super(serviceContainer);
     }
     public isSupported(resource?: Uri): Promise<boolean> {
         return this.isPipAvailable(resource);
     }
     protected async getExecutionInfo(moduleName: string, resource?: Uri): Promise<ExecutionInfo> {
-        const proxyArgs = [];
+        const proxyArgs: string[] = [];
         const proxy = workspace.getConfiguration('http').get('proxy', '');
         if (proxy.length > 0) {
             proxyArgs.push('--proxy');

src/client/common/installer/serviceRegistry.ts

@@ -5,11 +5,13 @@
 import { IServiceManager } from '../../ioc/types';
 import { InstallationChannelManager } from './channelManager';
 import { CondaInstaller } from './condaInstaller';
+import { PipEnvInstaller } from './pipEnvInstaller';
 import { PipInstaller } from './pipInstaller';
 import { IInstallationChannelManager, IModuleInstaller } from './types';
 
 export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<IModuleInstaller>(IModuleInstaller, CondaInstaller);
     serviceManager.addSingleton<IModuleInstaller>(IModuleInstaller, PipInstaller);
+    serviceManager.addSingleton<IModuleInstaller>(IModuleInstaller, PipEnvInstaller);
     serviceManager.addSingleton<IInstallationChannelManager>(IInstallationChannelManager, InstallationChannelManager);
 }

src/client/common/installer/types.ts

@@ -7,6 +7,7 @@ import { Product } from '../types';
 export const IModuleInstaller = Symbol('IModuleInstaller');
 export interface IModuleInstaller {
     readonly displayName: string;
+    readonly priority: number;
     installModule(name: string, resource?: Uri): Promise<void>;
     isSupported(resource?: Uri): Promise<boolean>;
 }

src/client/common/platform/platformService.ts

@@ -9,8 +9,8 @@ import { IPlatformService } from './types';
 
 @injectable()
 export class PlatformService implements IPlatformService {
-     private _isWindows: boolean;
-     private _isMac: boolean;
+    private _isWindows: boolean;
+    private _isMac: boolean;
 
     constructor() {
         this._isWindows = /^win/.test(process.platform);
@@ -30,4 +30,8 @@ export class PlatformService implements IPlatformService {
     }
     public get pathVariableName() {
         return this.isWindows ? WINDOWS_PATH_VARIABLE_NAME : NON_WINDOWS_PATH_VARIABLE_NAME;
-    }}
+    }
+    public get virtualEnvBinName() {
+        return this.isWindows ? 'scripts' : 'bin';
+    }
+}

src/client/common/platform/types.ts

@@ -25,6 +25,7 @@ export interface IPlatformService {
     isLinux: boolean;
     is64bit: boolean;
     pathVariableName: 'Path' | 'PATH';
+    virtualEnvBinName: 'bin' | 'scripts';
 }
 
 export const IFileSystem = Symbol('IFileSystem');

src/client/common/process/proc.ts

@@ -11,7 +11,7 @@ import { ExecutionResult, IBufferDecoder, IProcessService, ObservableExecutionRe
 
 @injectable()
 export class ProcessService implements IProcessService {
-    constructor( @inject(IBufferDecoder) private decoder: IBufferDecoder) { }
+    constructor(@inject(IBufferDecoder) private decoder: IBufferDecoder) { }
     public execObservable(file: string, args: string[], options: SpawnOptions = {}): ObservableExecutionResult<string> {
         const encoding = options.encoding = typeof options.encoding === 'string' && options.encoding.length > 0 ? options.encoding : DEFAULT_ENCODING;
         delete options.encoding;
@@ -72,7 +72,7 @@ export class ProcessService implements IProcessService {
 
         return { proc, out: output };
     }
-    public async exec(file: string, args: string[], options: SpawnOptions = {}): Promise<ExecutionResult<string>> {
+    public exec(file: string, args: string[], options: SpawnOptions = {}): Promise<ExecutionResult<string>> {
         const encoding = options.encoding = typeof options.encoding === 'string' && options.encoding.length > 0 ? options.encoding : DEFAULT_ENCODING;
         delete options.encoding;
         const spawnOptions = { ...options };

src/client/common/process/pythonProcess.ts

@@ -3,6 +3,7 @@
 
 import { injectable } from 'inversify';
 import { Uri } from 'vscode';
+import { IInterpreterVersionService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { ErrorUtils } from '../errors/errorUtils';
 import { ModuleNotInstalledError } from '../errors/moduleNotInstalledError';
@@ -13,24 +14,24 @@ import { ExecutionResult, IProcessService, IPythonExecutionService, ObservableEx
 
 @injectable()
 export class PythonExecutionService implements IPythonExecutionService {
-    private procService: IProcessService;
-    private configService: IConfigurationService;
-    private fileSystem: IFileSystem;
+    private readonly procService: IProcessService;
+    private readonly configService: IConfigurationService;
+    private readonly fileSystem: IFileSystem;
 
-    constructor(serviceContainer: IServiceContainer, private envVars: EnvironmentVariables | undefined, private resource?: Uri) {
+    constructor(private serviceContainer: IServiceContainer, private envVars: EnvironmentVariables | undefined, private resource?: Uri) {
         this.procService = serviceContainer.get<IProcessService>(IProcessService);
         this.configService = serviceContainer.get<IConfigurationService>(IConfigurationService);
         this.fileSystem = serviceContainer.get<IFileSystem>(IFileSystem);
     }
 
     public async getVersion(): Promise<string> {
-        return this.procService.exec(this.pythonPath, ['--version'], { env: this.envVars, mergeStdOutErr: true })
-            .then(output => output.stdout.trim());
+        const versionService = this.serviceContainer.get<IInterpreterVersionService>(IInterpreterVersionService);
+        return versionService.getVersion(this.pythonPath, '');
     }
     public async getExecutablePath(): Promise<string> {
         // If we've passed the python file, then return the file.
         // This is because on mac if using the interpreter /usr/bin/python2.7 we can get a different value for the path
-        if (await this.fileSystem.fileExistsAsync(this.pythonPath)){
+        if (await this.fileSystem.fileExistsAsync(this.pythonPath)) {
             return this.pythonPath;
         }
         return this.procService.exec(this.pythonPath, ['-c', 'import sys;print(sys.executable)'], { env: this.envVars, throwOnStdErr: true })

src/client/common/process/types.ts

@@ -50,7 +50,6 @@ export interface IPythonExecutionFactory {
 export const IPythonExecutionService = Symbol('IPythonExecutionService');
 
 export interface IPythonExecutionService {
-    getVersion(): Promise<string>;
     getExecutablePath(): Promise<string>;
     isModuleInstalled(moduleName: string): Promise<boolean>;
 

src/client/common/types.ts

@@ -2,7 +2,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import {Socket} from 'net';
+import { Socket } from 'net';
 import { ConfigurationTarget, DiagnosticSeverity, Disposable, Uri } from 'vscode';
 
 import { EnvironmentVariables } from './variables/types';
@@ -96,6 +96,7 @@ export interface ICurrentProcess {
 export interface IPythonSettings {
     readonly pythonPath: string;
     readonly venvPath: string;
+    readonly venvFolders: string[];
     readonly jediPath: string;
     readonly jediMemoryLimit: number;
     readonly devOptions: string[];

src/client/interpreter/contracts.ts

@@ -9,6 +9,7 @@ export const CURRENT_PATH_SERVICE = 'CurrentPathService';
 export const KNOWN_PATH_SERVICE = 'KnownPathsService';
 export const GLOBAL_VIRTUAL_ENV_SERVICE = 'VirtualEnvService';
 export const WORKSPACE_VIRTUAL_ENV_SERVICE = 'WorkspaceVirtualEnvService';
+export const PIPENV_SERVICE = 'PipEnvService';
 
 export const IInterpreterVersionService = Symbol('IInterpreterVersionService');
 export interface IInterpreterVersionService {