Check our saved jupyter interpreters before allowing any of them to be used as active interpreters

src/client/common/process/types.ts

@@ -113,8 +113,8 @@ export interface IPythonExecutionFactory {
     create(options: ExecutionFactoryCreationOptions): Promise<IPythonExecutionService>;
     /**
      * Creates a daemon Python Process.
-     * On windows its cheapter to create a daemon and use that than spin up Python Processes everytime.
-     * If something cannot be executed within the daemin, it will resort to using the stanard IPythonExecutionService.
+     * On windows it's cheaper to create a daemon and use that than spin up Python Processes everytime.
+     * If something cannot be executed within the daemon, it will resort to using the standard IPythonExecutionService.
      * Note: The returned execution service is always using an activated environment.
      *
      * @param {ExecutionFactoryCreationOptions} options

src/client/datascience/activation.ts

@@ -28,6 +28,7 @@ export class Activation implements IExtensionSingleActivationService {
     public async activate(): Promise<void> {
         this.disposables.push(this.notebookProvider.onDidOpenNotebookEditor(this.onDidOpenNotebookEditor, this));
         this.disposables.push(this.jupyterInterpreterService.onDidChangeInterpreter(this.onDidChangeInterpreter, this));
+        this.testSavedInterpreter();
         await this.contextService.activate();
     }
 
@@ -43,6 +44,11 @@ export class Activation implements IExtensionSingleActivationService {
         }
     }
 
+    private testSavedInterpreter(): void {
+        // Do we have a saved interpreter? If so check it out to see if it's still valid
+        this.jupyterInterpreterService.checkSavedInterpreter().ignoreErrors();
+    }
+
     @debounceAsync(500)
     @swallowExceptions('Failed to pre-warm daemon pool')
     private async PreWarmDaemonPool() {

src/client/datascience/jupyter/interpreter/jupyterInterpreterService.ts

@@ -8,6 +8,7 @@ import { Event, EventEmitter } from 'vscode';
 import { CancellationToken } from 'vscode-jsonrpc';
 import { createPromiseFromCancellation } from '../../../common/cancellation';
 import '../../../common/extensions';
+import { traceInfo } from '../../../common/logger';
 import { IInterpreterService, PythonInterpreter } from '../../../interpreter/contracts';
 import { sendTelemetryEvent } from '../../../telemetry';
 import { Telemetry } from '../../constants';
@@ -89,6 +90,36 @@ export class JupyterInterpreterService {
         }
         return interpreterDetails;
     }
+
+    // Verify if a saved global interpreter is still valid for use
+    // If not, then clear it out
+    public async checkSavedInterpreter(): Promise<void> {
+        if (!this.interpreterSelectionState.selectedPythonPath) {
+            // None set yet, so no need to check
+            return;
+        }
+
+        try {
+            const interpreterDetails = await this.interpreterService.getInterpreterDetails(
+                this.interpreterSelectionState.selectedPythonPath,
+                undefined
+            );
+
+            if (interpreterDetails) {
+                if (await this.interpreterConfiguration.areDependenciesInstalled(interpreterDetails, undefined)) {
+                    // Our saved interpreter was found and has dependencies installed
+                    return;
+                }
+            }
+        } catch (_err) {
+            traceInfo('Saved Jupyter interpreter invalid');
+        }
+
+        // At this point we failed some aspect of our checks regarding our saved interpreter, so clear it out
+        this._selectedInterpreter = undefined;
+        this.interpreterSelectionState.updateSelectedPythonPath(undefined);
+    }
+
     /**
      * Selects and interpreter to run jupyter server.
      * Validates and configures the interpreter.

src/client/datascience/jupyter/interpreter/jupyterInterpreterStateStore.ts

@@ -11,11 +11,11 @@ import { noop } from '../../../common/utils/misc';
 const key = 'INTERPRETER_PATH_SELECTED_FOR_JUPYTER_SERVER';
 const keySelected = 'INTERPRETER_PATH_WAS_SELECTED_FOR_JUPYTER_SERVER';
 /**
- * Keeps track of whether the user ever selected an interpreter to be used as the gloabl jupyter interpreter.
+ * Keeps track of whether the user ever selected an interpreter to be used as the global jupyter interpreter.
  * Keeps track of the interpreter path of the interpreter used as the global jupyter interpreter.
  *
  * @export
- * @class JupyterInterpreterFinderEverSet
+ * @class JupyterInterpreterStateStore
  */
 @injectable()
 export class JupyterInterpreterStateStore {
@@ -27,15 +27,14 @@ export class JupyterInterpreterStateStore {
      *
      * @readonly
      * @type {Promise<boolean>}
-     * @memberof JupyterInterpreterFinderEverSet
      */
     public get interpreterSetAtleastOnce(): boolean {
         return !!this.selectedPythonPath || this.memento.get<boolean>(keySelected, false);
     }
     public get selectedPythonPath(): string | undefined {
         return this._interpreterPath || this.memento.get<string | undefined>(key, undefined);
     }
-    public updateSelectedPythonPath(value: string) {
+    public updateSelectedPythonPath(value: string | undefined) {
         this._interpreterPath = value;
         this.memento.update(key, value).then(noop, noop);
         this.memento.update(keySelected, true).then(noop, noop);