@@ -0,0 +1 @@
+Create a new API to retrieve interpreter details with the ability to cache the details.
@@ -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))
@@ -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) {
 
@@ -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;
     }
 
 
@@ -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);
     }
 
@@ -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);
 
@@ -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);
     }
 }
@@ -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);
+                }
+            });
+        });
+    }
 }
@@ -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>;
 }
@@ -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);
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+Create a new API to retrieve interpreter details with the ability to cache the details.`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ export class PipInstaller extends ModuleInstaller implements IModuleInstaller {`
`38`	`38`	`}`
`39`	`39`	`private isPipAvailable(resource?: Uri): Promise<boolean> {`
`40`	`40`	`const pythonExecutionFactory = this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);`
`41`		`- return pythonExecutionFactory.create(resource)`
	`41`	`+ return pythonExecutionFactory.create({ resource })`
`42`	`42`	`.then(proc => proc.isModuleInstalled('pip'))`
`43`	`43`	`.catch(() => false);`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,4 +46,5 @@ export interface IFileSystem {`
`46`	`46`	`getRealPath(path: string): Promise<string>;`
`47`	`47`	`copyFile(src: string, dest: string): Promise<void>;`
`48`	`48`	`deleteFile(filename: string): Promise<void>;`
	`49`	`+ getFileHash(filePath: string): Promise<string \| undefined>;`
`49`	`50`	`}`