Create a new API to retrieve interpreter details with the ability to cache the details (microsoft#1567)

Fixes microsoft#1569

Author: DonJayamanne

news/3 Code Health/1569.md

@@ -0,0 +1 @@
+Create a new API to retrieve interpreter details with the ability to cache the details.

pythonFiles/interpreterInfo.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import json
+import sys
+
+obj = {}
+obj["versionInfo"] = sys.version_info[:4]
+obj["sysPrefix"] = sys.prefix
+obj["version"] = sys.version
+obj["is64Bit"] = sys.maxsize > 2**32
+
+print(json.dumps(obj))

src/client/activation/interpreterDataService.ts

@@ -33,7 +33,7 @@ export class InterpreterDataService {
 
  public async getInterpreterData(resource?: Uri): Promise<InterpreterData | undefined> {
  const executionFactory = this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
- const execService = await executionFactory.create(resource);
+ const execService = await executionFactory.create({ resource });
 
  const interpreterPath = await execService.getExecutablePath();
  if (interpreterPath.length === 0) {

src/client/common/installer/channelManager.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 import { inject, injectable } from 'inversify';
-import { QuickPickItem, Uri } from 'vscode';
+import { Uri } from 'vscode';
 import { IInterpreterService, InterpreterType } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { IApplicationShell } from '../application/types';
@@ -34,9 +34,9 @@ export class InstallationChannelManager implements IInstallationChannelManager {
  label: `Install using ${installer.displayName}`,
  description: '',
  installer
- } as QuickPickItem & { installer: IModuleInstaller };
+ };
  });
- const selection = await appShell.showQuickPick(options, { matchOnDescription: true, matchOnDetail: true, placeHolder });
+ const selection = await appShell.showQuickPick<typeof options[0]>(options, { matchOnDescription: true, matchOnDetail: true, placeHolder });
  return selection ? selection.installer : undefined;
  }
 

src/client/common/installer/pipInstaller.ts

@@ -38,7 +38,7 @@ export class PipInstaller extends ModuleInstaller implements IModuleInstaller {
  }
  private isPipAvailable(resource?: Uri): Promise<boolean> {
  const pythonExecutionFactory = this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
- return pythonExecutionFactory.create(resource)
+ return pythonExecutionFactory.create({ resource })
  .then(proc => proc.isModuleInstalled('pip'))
  .catch(() => false);
  }

src/client/common/installer/productInstaller.ts

@@ -74,7 +74,7 @@ abstract class BaseInstaller {
 
  const isModule = typeof moduleName === 'string' && moduleName.length > 0 && path.basename(executableName) === executableName;
  if (isModule) {
- const pythonProcess = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(resource);
+ const pythonProcess = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create({ resource });
  return pythonProcess.isModuleInstalled(executableName);
  } else {
  const process = await this.serviceContainer.get<IProcessServiceFactory>(IProcessServiceFactory).create(resource);

src/client/common/persistentState.ts

@@ -8,25 +8,38 @@ import { Memento } from 'vscode';
 import { GLOBAL_MEMENTO, IMemento, IPersistentState, IPersistentStateFactory, WORKSPACE_MEMENTO } from './types';
 
 class PersistentState<T> implements IPersistentState<T>{
- constructor(private storage: Memento, private key: string, private defaultValue: T) { }
+ constructor(private storage: Memento, private key: string, private defaultValue?: T, private expiryDurationMs?: number) { }
 
  public get value(): T {
- return this.storage.get<T>(this.key, this.defaultValue);
+ if (this.expiryDurationMs) {
+ const cachedData = this.storage.get<{ data?: T; expiry?: number }>(this.key, { data: this.defaultValue! });
+ if (!cachedData || !cachedData.expiry || cachedData.expiry < Date.now()) {
+ return this.defaultValue!;
+ } else {
+ return cachedData.data!;
+ }
+ } else {
+ return this.storage.get<T>(this.key, this.defaultValue!);
+ }
  }
 
  public async updateValue(newValue: T): Promise<void> {
- await this.storage.update(this.key, newValue);
+ if (this.expiryDurationMs) {
+ await this.storage.update(this.key, { data: newValue, expiry: Date.now() + this.expiryDurationMs });
+ } else {
+ await this.storage.update(this.key, newValue);
+ }
  }
 }
 
 @injectable()
 export class PersistentStateFactory implements IPersistentStateFactory {
- constructor( @inject(IMemento) @named(GLOBAL_MEMENTO) private globalState: Memento,
+ constructor(@inject(IMemento) @named(GLOBAL_MEMENTO) private globalState: Memento,
  @inject(IMemento) @named(WORKSPACE_MEMENTO) private workspaceState: Memento) { }
- public createGlobalPersistentState<T>(key: string, defaultValue: T): IPersistentState<T> {
- return new PersistentState<T>(this.globalState, key, defaultValue);
+ public createGlobalPersistentState<T>(key: string, defaultValue?: T, expiryDurationMs?: number): IPersistentState<T> {
+ return new PersistentState<T>(this.globalState, key, defaultValue, expiryDurationMs);
  }
- public createWorkspacePersistentState<T>(key: string, defaultValue: T): IPersistentState<T> {
- return new PersistentState<T>(this.workspaceState, key, defaultValue);
+ public createWorkspacePersistentState<T>(key: string, defaultValue?: T, expiryDurationMs?: number): IPersistentState<T> {
+ return new PersistentState<T>(this.workspaceState, key, defaultValue, expiryDurationMs);
  }
 }

src/client/common/platform/fileSystem.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 'use strict';
 
+import { createHash } from 'crypto';
 import * as fs from 'fs-extra';
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
@@ -117,4 +118,16 @@ export class FileSystem implements IFileSystem {
  fs.unlink(filename, err => err ? deferred.reject(err) : deferred.resolve());
  return deferred.promise;
  }
+ public getFileHash(filePath: string): Promise<string | undefined> {
+ return new Promise<string | undefined>(resolve => {
+ fs.lstat(filePath, (err, stats) => {
+ if (err) {
+ resolve();
+ } else {
+ const actual = createHash('sha512').update(`${stats.ctimeMs}-${stats.mtimeMs}`).digest('hex');
+ resolve(actual);
+ }
+ });
+ });
+ }
 }

src/client/common/platform/types.ts

@@ -46,4 +46,5 @@ export interface IFileSystem {
  getRealPath(path: string): Promise<string>;
  copyFile(src: string, dest: string): Promise<void>;
  deleteFile(filename: string): Promise<void>;
+ getFileHash(filePath: string): Promise<string | undefined>;
 }

src/client/common/process/pythonExecutionFactory.ts

@@ -4,17 +4,21 @@
 import { inject, injectable } from 'inversify';
 import { Uri } from 'vscode';
 import { IServiceContainer } from '../../ioc/types';
+import { IConfigurationService } from '../types';
 import { PythonExecutionService } from './pythonProcess';
-import { IProcessServiceFactory, IPythonExecutionFactory, IPythonExecutionService } from './types';
+import { ExecutionFactoryCreationOptions, IProcessServiceFactory, IPythonExecutionFactory, IPythonExecutionService } from './types';
 
 @injectable()
 export class PythonExecutionFactory implements IPythonExecutionFactory {
+ private readonly configService: IConfigurationService;
  private processServiceFactory: IProcessServiceFactory;
  constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
  this.processServiceFactory = serviceContainer.get<IProcessServiceFactory>(IProcessServiceFactory);
+ this.configService = serviceContainer.get<IConfigurationService>(IConfigurationService);
  }
- public async create(resource?: Uri): Promise<IPythonExecutionService> {
- const processService = await this.processServiceFactory.create(resource);
- return new PythonExecutionService(this.serviceContainer, processService, resource);
+ public async create(options: ExecutionFactoryCreationOptions): Promise<IPythonExecutionService> {
+ const pythonPath = options.pythonPath ? options.pythonPath : this.configService.getSettings(options.resource).pythonPath;
+ const processService = await this.processServiceFactory.create(options.resource);
+ return new PythonExecutionService(this.serviceContainer, processService, pythonPath);
  }
 }