Add getMatchingInterpreter API (#8796)

* Add getMatchingInterpreter as the API to go between kernel spec and interpreter

* Fix functional tests

* Linter error

Author: rchiodo

src/client/datascience/jupyter/jupyterNotebook.ts

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-'use strict';
 import '../../common/extensions';
 
 // tslint:disable-next-line: no-require-imports
@@ -23,6 +22,7 @@ import { createDeferred, Deferred, waitForPromise } from '../../common/utils/asy
 import * as localize from '../../common/utils/localize';
 import { noop } from '../../common/utils/misc';
 import { StopWatch } from '../../common/utils/stopWatch';
+import { IInterpreterService, PythonInterpreter } from '../../interpreter/contracts';
 import { captureTelemetry, sendTelemetryEvent } from '../../telemetry';
 import { generateCells } from '../cellFactory';
 import { CellMatcher } from '../cellMatcher';
@@ -145,6 +145,7 @@ export class JupyterNotebookBase implements INotebook {
     private _disposed: boolean = false;
     private _workingDirectory: string | undefined;
     private _loggers: INotebookExecutionLogger[] = [];
+    private interpreter: PythonInterpreter | undefined;
 
     constructor(
         _liveShare: ILiveShareApi, // This is so the liveshare mixin works
@@ -157,11 +158,15 @@ export class JupyterNotebookBase implements INotebook {
         resource: Uri,
         private getDisposedError: () => Error,
         private workspace: IWorkspaceService,
-        private applicationService: IApplicationShell
+        private applicationService: IApplicationShell,
+        private interpreterService: IInterpreterService
     ) {
         this.sessionStartTime = Date.now();
         this._resource = resource;
         this._loggers = [...loggers];
+        // Save our interpreter and don't change it. Later on when kernel changes
+        // are possible, recompute it.
+        this.interpreterService.getActiveInterpreter(resource).then(i => this.interpreter = i).ignoreErrors();
     }
 
     public get server(): INotebookServer {
@@ -438,7 +443,7 @@ export class JupyterNotebookBase implements INotebook {
                 cursor_pos: offsetInCode
             }), cancelToken);
             if (result && result.content) {
-                if ('matches' in result.content){
+                if ('matches' in result.content) {
                     return {
                         matches: result.content.matches,
                         cursor: {
@@ -450,7 +455,7 @@ export class JupyterNotebookBase implements INotebook {
                 } else {
                     return {
                         matches: [],
-                        cursor : {start: 0, end: 0},
+                        cursor: { start: 0, end: 0 },
                         metadata: []
                     };
                 }
@@ -461,6 +466,10 @@ export class JupyterNotebookBase implements INotebook {
         throw new Error(localize.DataScience.sessionDisposed());
     }
 
+    public async getMatchingInterpreter(): Promise<PythonInterpreter | undefined> {
+        return this.interpreter;
+    }
+
     private finishUncompletedCells() {
         const copyPending = [...this.pendingCellSubscriptions];
         copyPending.forEach(c => c.cancel());
@@ -734,7 +743,7 @@ export class JupyterNotebookBase implements INotebook {
                         .catch(e => {
                             // @jupyterlab/services throws a `Canceled` error when the kernel is interrupted.
                             // Such an error must be ignored.
-                            if (e && e instanceof Error && e.message === 'Canceled'){
+                            if (e && e instanceof Error && e.message === 'Canceled') {
                                 subscriber.complete(this.sessionStartTime);
                             } else {
                                 subscriber.error(this.sessionStartTime, e);

src/client/datascience/jupyter/jupyterServerFactory.ts

@@ -11,6 +11,7 @@ import * as vsls from 'vsls/vscode';
 
 import { IApplicationShell, ILiveShareApi, IWorkspaceService } from '../../common/application/types';
 import { IAsyncDisposableRegistry, IConfigurationService, IDisposableRegistry } from '../../common/types';
+import { IInterpreterService } from '../../interpreter/contracts';
 import {
     IConnection,
     IDataScience,
@@ -38,7 +39,8 @@ type JupyterServerClassType = {
         sessionManager: IJupyterSessionManagerFactory,
         workspaceService: IWorkspaceService,
         loggers: INotebookExecutionLogger[],
-        appShell: IApplicationShell
+        appShell: IApplicationShell,
+        interpreterService: IInterpreterService
     ): IJupyterServerInterface;
 };
 // tslint:enable:callable-types
@@ -59,7 +61,8 @@ export class JupyterServerFactory implements INotebookServer, ILiveShareHasRole
         @inject(IJupyterSessionManagerFactory) sessionManager: IJupyterSessionManagerFactory,
         @inject(IWorkspaceService) workspaceService: IWorkspaceService,
         @multiInject(INotebookExecutionLogger) @optional() loggers: INotebookExecutionLogger[] | undefined,
-        @inject(IApplicationShell) appShell: IApplicationShell) {
+        @inject(IApplicationShell) appShell: IApplicationShell,
+        @inject(IInterpreterService) interpreterService: IInterpreterService) {
         this.serverFactory = new RoleBasedFactory<IJupyterServerInterface, JupyterServerClassType>(
             liveShare,
             HostJupyterServer,
@@ -72,7 +75,8 @@ export class JupyterServerFactory implements INotebookServer, ILiveShareHasRole
             sessionManager,
             workspaceService,
             loggers ? loggers : [],
-            appShell
+            appShell,
+            interpreterService
         );
     }
 

src/client/datascience/jupyter/liveshare/guestJupyterNotebook.ts

@@ -13,8 +13,16 @@ import { IConfigurationService, IDisposableRegistry } from '../../../common/type
 import { createDeferred } from '../../../common/utils/async';
 import * as localize from '../../../common/utils/localize';
 import { noop } from '../../../common/utils/misc';
+import { PythonInterpreter } from '../../../interpreter/contracts';
 import { LiveShare, LiveShareCommands } from '../../constants';
-import { ICell, INotebook, INotebookCompletion, INotebookExecutionLogger, INotebookServer, InterruptResult } from '../../types';
+import {
+    ICell,
+    INotebook,
+    INotebookCompletion,
+    INotebookExecutionLogger,
+    INotebookServer,
+    InterruptResult
+} from '../../types';
 import { LiveShareParticipantDefault, LiveShareParticipantGuest } from './liveShareParticipantMixin';
 import { ResponseQueue } from './responseQueue';
 import { IExecuteObservableResponse, ILiveShareParticipant, IServerResponse } from './types';
@@ -172,6 +180,10 @@ export class GuestJupyterNotebook
         }
     }
 
+    public getMatchingInterpreter(): Promise<PythonInterpreter | undefined> {
+        return Promise.resolve(undefined);
+    }
+
     private onServerResponse = (args: Object) => {
         const er = args as IExecuteObservableResponse;
         traceInfo(`Guest serverResponse ${er.pos} ${er.id}`);

src/client/datascience/jupyter/liveshare/hostJupyterNotebook.ts

@@ -14,6 +14,7 @@ import { IApplicationShell, ILiveShareApi, IWorkspaceService } from '../../../co
 import { traceError } from '../../../common/logger';
 import { IConfigurationService, IDisposableRegistry } from '../../../common/types';
 import { createDeferred } from '../../../common/utils/async';
+import { IInterpreterService } from '../../../interpreter/contracts';
 import { Identifiers, LiveShare, LiveShareCommands } from '../../constants';
 import { IExecuteInfo } from '../../interactive-common/interactiveWindowTypes';
 import {
@@ -52,9 +53,10 @@ export class HostJupyterNotebook
         resource: vscode.Uri,
         getDisposedError: () => Error,
         workspace: IWorkspaceService,
-        appService: IApplicationShell
+        appService: IApplicationShell,
+        interpreterService: IInterpreterService
     ) {
-        super(liveShare, session, configService, disposableRegistry, owner, launchInfo, loggers, resource, getDisposedError, workspace, appService);
+        super(liveShare, session, configService, disposableRegistry, owner, launchInfo, loggers, resource, getDisposedError, workspace, appService, interpreterService);
     }
 
     public dispose = async (): Promise<void> => {

src/client/datascience/jupyter/liveshare/hostJupyterServer.ts

@@ -13,6 +13,7 @@ import { traceInfo } from '../../../common/logger';
 import { IAsyncDisposableRegistry, IConfigurationService, IDisposableRegistry } from '../../../common/types';
 import * as localize from '../../../common/utils/localize';
 import { StopWatch } from '../../../common/utils/stopWatch';
+import { IInterpreterService } from '../../../interpreter/contracts';
 import { sendTelemetryEvent } from '../../../telemetry';
 import { Identifiers, LiveShare, LiveShareCommands, RegExpValues, Telemetry } from '../../constants';
 import {
@@ -48,7 +49,9 @@ export class HostJupyterServer
         sessionManager: IJupyterSessionManagerFactory,
         private workspaceService: IWorkspaceService,
         loggers: INotebookExecutionLogger[],
-        private appService: IApplicationShell) {
+        private appService: IApplicationShell,
+        private interpreterService: IInterpreterService
+    ) {
         super(liveShare, asyncRegistry, disposableRegistry, configService, sessionManager, loggers);
     }
 
@@ -177,7 +180,8 @@ export class HostJupyterServer
                 resource,
                 this.getDisposedError.bind(this),
                 this.workspaceService,
-                this.appService);
+                this.appService,
+                this.interpreterService);
 
             // Wait for it to be ready
             traceInfo(`Waiting for idle (session) ${this.id}`);

src/client/datascience/types.ts

@@ -100,6 +100,7 @@ export interface INotebook extends IAsyncDisposable {
     getSysInfo(): Promise<ICell | undefined>;
     setMatplotLibStyle(useDark: boolean): Promise<void>;
     addLogger(logger: INotebookExecutionLogger): void;
+    getMatchingInterpreter(): Promise<PythonInterpreter | undefined>;
 }
 
 export interface INotebookServerOptions {

src/test/datascience/execution.unit.test.ts

@@ -123,6 +123,10 @@ class MockJupyterNotebook implements INotebook {
     public async dispose(): Promise<void> {
         return Promise.resolve();
     }
+
+    public getMatchingInterpreter(): Promise<PythonInterpreter | undefined> {
+        return Promise.resolve(undefined);
+    }
 }
 
 // tslint:disable:no-any no-http-string no-multiline-string max-func-body-length
@@ -538,7 +542,7 @@ suite('Jupyter Execution', async () => {
     function createExecution(activeInterpreter: PythonInterpreter, notebookStdErr?: string[], skipSearch?: boolean): JupyterExecutionFactory {
         return createExecutionAndReturnProcessService(activeInterpreter, notebookStdErr, skipSearch).jupyterExecutionFactory;
     }
-    function createExecutionAndReturnProcessService(activeInterpreter: PythonInterpreter, notebookStdErr?: string[], skipSearch?: boolean, runInDocker?: boolean): {workingPythonExecutionService: TypeMoq.IMock<IPythonExecutionService>; jupyterExecutionFactory: JupyterExecutionFactory} {
+    function createExecutionAndReturnProcessService(activeInterpreter: PythonInterpreter, notebookStdErr?: string[], skipSearch?: boolean, runInDocker?: boolean): { workingPythonExecutionService: TypeMoq.IMock<IPythonExecutionService>; jupyterExecutionFactory: JupyterExecutionFactory } {
         // Setup defaults
         when(interpreterService.onDidChangeInterpreter).thenReturn(dummyEvent.event);
         when(interpreterService.getActiveInterpreter()).thenResolve(activeInterpreter);
@@ -547,7 +551,7 @@ suite('Jupyter Execution', async () => {
         when(interpreterService.getInterpreterDetails(match('/foo/baz/python.exe'))).thenResolve(missingKernelPython);
         when(interpreterService.getInterpreterDetails(match('/bar/baz/python.exe'))).thenResolve(missingNotebookPython);
         when(interpreterService.getInterpreterDetails(argThat(o => !o.includes || !o.includes('python')))).thenReject('Unknown interpreter');
-        if (runInDocker){
+        if (runInDocker) {
             when(fileSystem.readFile('/proc/self/cgroup')).thenResolve('hello docker world');
         }
         // Create our working python and process service.
@@ -692,7 +696,7 @@ suite('Jupyter Execution', async () => {
     }
 
     test('Working notebook and commands found', async () => {
-        const { workingPythonExecutionService, jupyterExecutionFactory} = createExecutionAndReturnProcessService(workingPython);
+        const { workingPythonExecutionService, jupyterExecutionFactory } = createExecutionAndReturnProcessService(workingPython);
         when(executionFactory.createDaemon(deepEqual({ daemonModule: PythonDaemonModule, pythonPath: workingPython.path }))).thenResolve(workingPythonExecutionService.object);
 
         await assert.eventually.equal(jupyterExecutionFactory.isNotebookSupported(), true, 'Notebook not supported');
@@ -705,7 +709,7 @@ suite('Jupyter Execution', async () => {
     }).timeout(10000);
 
     test('Includes correct args for running in docker', async () => {
-        const { workingPythonExecutionService, jupyterExecutionFactory} = createExecutionAndReturnProcessService(workingPython, undefined, undefined, true);
+        const { workingPythonExecutionService, jupyterExecutionFactory } = createExecutionAndReturnProcessService(workingPython, undefined, undefined, true);
         when(executionFactory.createDaemon(deepEqual({ daemonModule: PythonDaemonModule, pythonPath: workingPython.path }))).thenResolve(workingPythonExecutionService.object);
 
         await assert.eventually.equal(jupyterExecutionFactory.isNotebookSupported(), true, 'Notebook not supported');
@@ -732,7 +736,7 @@ suite('Jupyter Execution', async () => {
     test('Slow notebook startups throws exception', async () => {
         const daemonService = mock(PythonDaemonExecutionService);
         const stdErr = 'Failure';
-        const proc = {on: noop} as any as ChildProcess;
+        const proc = { on: noop } as any as ChildProcess;
         const out = new Observable<Output<string>>(s => s.next({ source: 'stderr', out: stdErr }));
         when(daemonService.execModuleObservable(anything(), anything(), anything())).thenReturn({ dispose: noop, proc: proc, out });
         when(executionFactory.createDaemon(deepEqual({ daemonModule: PythonDaemonModule, pythonPath: workingPython.path }))).thenResolve(instance(daemonService));
@@ -856,7 +860,7 @@ suite('Jupyter Execution', async () => {
     }).timeout(20_000);
 
     test('Kernelspec is deleted on exit', async () => {
-        const { workingPythonExecutionService, jupyterExecutionFactory} = createExecutionAndReturnProcessService(missingKernelPython);
+        const { workingPythonExecutionService, jupyterExecutionFactory } = createExecutionAndReturnProcessService(missingKernelPython);
         when(interpreterService.getActiveInterpreter(undefined)).thenResolve(missingKernelPython);
         when(executionFactory.createDaemon(deepEqual({ daemonModule: PythonDaemonModule, pythonPath: missingKernelPython.path }))).thenResolve(workingPythonExecutionService.object);
 

src/test/datascience/mockJupyterManager.ts

@@ -77,6 +77,7 @@ export class MockJupyterManager implements IJupyterSessionManager {
         // Setup our interpreter service
         this.interpreterService.setup(i => i.onDidChangeInterpreter).returns(() => this.changedInterpreterEvent.event);
         this.interpreterService.setup(i => i.getActiveInterpreter()).returns(() => Promise.resolve(this.activeInterpreter));
+        this.interpreterService.setup(i => i.getActiveInterpreter(TypeMoq.It.isAny())).returns(() => Promise.resolve(this.activeInterpreter));
         this.interpreterService.setup(i => i.getInterpreters()).returns(() => Promise.resolve(this.installedInterpreters));
         this.interpreterService.setup(i => i.getInterpreterDetails(TypeMoq.It.isAnyString())).returns((p) => {
             const found = this.installedInterpreters.find(i => i.path === p);