Hook up kernel selection to the kernel finder (part 1) (#11505)

Author: IanMatthewHuff

src/client/datascience/interactive-common/interactiveBase.ts

@@ -1069,7 +1069,11 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
                 // If we get an invalid kernel error, make sure to ask the user to switch
                 if (e instanceof JupyterInvalidKernelError && serverConnection && serverConnection.localLaunch) {
                     // Ask the user for a new local kernel
-                    const newKernel = await this.switcher.askForLocalKernel(resource, e.kernelSpec);
+                    const newKernel = await this.switcher.askForLocalKernel(
+                        resource,
+                        serverConnection.type,
+                        e.kernelSpec
+                    );
                     if (newKernel?.kernelSpec) {
                         // Update the notebook metadata
                         await this.updateNotebookOptions(newKernel.kernelSpec, newKernel.interpreter);

src/client/datascience/jupyter/jupyterExecution.ts

@@ -231,6 +231,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
                                     const sessionManager = await sessionManagerFactory.create(connection);
                                     const kernelInterpreter = await this.kernelSelector.selectLocalKernel(
                                         undefined,
+                                        'jupyter',
                                         new StopWatch(),
                                         sessionManager,
                                         cancelToken,

src/client/datascience/jupyter/kernels/kernelSelections.ts

@@ -10,6 +10,7 @@ import { IFileSystem } from '../../../common/platform/types';
 import { IPathUtils, Resource } from '../../../common/types';
 import * as localize from '../../../common/utils/localize';
 import { IInterpreterSelector } from '../../../interpreter/configuration/types';
+import { IKernelFinder } from '../../kernel-launcher/types';
 import { IJupyterKernelSpec, IJupyterSessionManager } from '../../types';
 import { KernelService } from './kernelService';
 import { IKernelSelectionListProvider, IKernelSpecQuickPickItem, LiveKernelModel } from './types';
@@ -117,6 +118,20 @@ export class InstalledJupyterKernelSelectionListProvider implements IKernelSelec
     }
 }
 
+// Provider for searching for installed kernelspecs on disk without using jupyter to search
+export class InstalledRawKernelSelectionListProvider implements IKernelSelectionListProvider {
+    constructor(private readonly kernelFinder: IKernelFinder, private readonly pathUtils: IPathUtils) {}
+    public async getKernelSelections(
+        _resource: Resource,
+        cancelToken?: CancellationToken
+    ): Promise<IKernelSpecQuickPickItem[]> {
+        const items = await this.kernelFinder.listKernelSpecs(cancelToken);
+        return items
+            .filter((item) => (item.language || '').toLowerCase() === PYTHON_LANGUAGE.toLowerCase())
+            .map((item) => getQuickPickItemForKernelSpec(item, this.pathUtils));
+    }
+}
+
 /**
  * Provider for interpreters to be treated as kernel specs.
  * I.e. return interpreters that are to be treated as kernel specs, and not yet installed as kernels.
@@ -157,7 +172,8 @@ export class KernelSelectionProvider {
         @inject(KernelService) private readonly kernelService: KernelService,
         @inject(IInterpreterSelector) private readonly interpreterSelector: IInterpreterSelector,
         @inject(IFileSystem) private readonly fileSystem: IFileSystem,
-        @inject(IPathUtils) private readonly pathUtils: IPathUtils
+        @inject(IPathUtils) private readonly pathUtils: IPathUtils,
+        @inject(IKernelFinder) private readonly kernelFinder: IKernelFinder
     ) {}
     /**
      * Gets a selection of kernel specs from a remote session.
@@ -206,15 +222,32 @@ export class KernelSelectionProvider {
      */
     public async getKernelSelectionsForLocalSession(
         resource: Resource,
+        type: 'raw' | 'jupyter' | 'noConnection',
         sessionManager?: IJupyterSessionManager,
         cancelToken?: CancellationToken
     ): Promise<IKernelSpecQuickPickItem[]> {
         const getSelections = async () => {
-            const installedKernelsPromise = new InstalledJupyterKernelSelectionListProvider(
-                this.kernelService,
-                this.pathUtils,
-                sessionManager
-            ).getKernelSelections(resource, cancelToken);
+            // For raw versus jupyter connections we need to use a different method for fetching installed kernelspecs
+            // There is a possible unknown case for if we have a guest jupyter notebook that has not yet connected
+            // in that case we don't use either method
+            let installedKernelsPromise: Promise<IKernelSpecQuickPickItem[]> = Promise.resolve([]);
+            switch (type) {
+                case 'raw':
+                    installedKernelsPromise = new InstalledRawKernelSelectionListProvider(
+                        this.kernelFinder,
+                        this.pathUtils
+                    ).getKernelSelections(resource, cancelToken);
+                    break;
+                case 'jupyter':
+                    installedKernelsPromise = new InstalledJupyterKernelSelectionListProvider(
+                        this.kernelService,
+                        this.pathUtils,
+                        sessionManager
+                    ).getKernelSelections(resource, cancelToken);
+                    break;
+                default:
+                    break;
+            }
             const interpretersPromise = new InterpreterKernelSelectionListProvider(
                 this.interpreterSelector
             ).getKernelSelections(resource, cancelToken);

src/client/datascience/jupyter/kernels/kernelSelector.ts

@@ -104,6 +104,7 @@ export class KernelSelector {
         suggestions = suggestions.filter((item) => !this.kernelIdsToHide.has(item.selection.kernelModel?.id || ''));
         return this.selectKernel(
             resource,
+            'jupyter',
             stopWatch,
             Telemetry.SelectRemoteJupyterKernel,
             suggestions,
@@ -122,19 +123,22 @@ export class KernelSelector {
      */
     public async selectLocalKernel(
         resource: Resource,
+        type: 'raw' | 'jupyter' | 'noConnection',
         stopWatch: StopWatch,
         session?: IJupyterSessionManager,
         cancelToken?: CancellationToken,
         currentKernel?: IJupyterKernelSpec | LiveKernelModel
     ): Promise<KernelSpecInterpreter> {
         let suggestions = await this.selectionProvider.getKernelSelectionsForLocalSession(
             resource,
+            type,
             session,
             cancelToken
         );
         suggestions = suggestions.filter((item) => !this.kernelIdsToHide.has(item.selection.kernelModel?.id || ''));
         return this.selectKernel(
             resource,
+            type,
             stopWatch,
             Telemetry.SelectLocalJupyterKernel,
             suggestions,
@@ -169,7 +173,9 @@ export class KernelSelector {
         };
         // When this method is called, we know we've started a local jupyter server.
         // Lets pre-warm the list of local kernels.
-        this.selectionProvider.getKernelSelectionsForLocalSession(resource, sessionManager, cancelToken).ignoreErrors();
+        this.selectionProvider
+            .getKernelSelectionsForLocalSession(resource, 'jupyter', sessionManager, cancelToken)
+            .ignoreErrors();
 
         let selection: KernelSpecInterpreter = {};
         if (notebookMetadata?.kernelspec) {
@@ -198,14 +204,21 @@ export class KernelSelector {
                     selection = await this.useInterpreterAsKernel(
                         resource,
                         activeInterpreter,
+                        'jupyter',
                         notebookMetadata.kernelspec.display_name,
                         sessionManager,
                         disableUI,
                         cancelToken
                     );
                 } else {
                     telemetryProps.promptedToSelect = true;
-                    selection = await this.selectLocalKernel(resource, stopWatch, sessionManager, cancelToken);
+                    selection = await this.selectLocalKernel(
+                        resource,
+                        'jupyter',
+                        stopWatch,
+                        sessionManager,
+                        cancelToken
+                    );
                 }
             }
         } else {
@@ -302,6 +315,7 @@ export class KernelSelector {
     }
     private async selectKernel(
         resource: Resource,
+        type: 'raw' | 'jupyter' | 'noConnection',
         stopWatch: StopWatch,
         telemetryEvent: Telemetry,
         suggestions: IKernelSpecQuickPickItem[],
@@ -323,6 +337,7 @@ export class KernelSelector {
             return this.useInterpreterAsKernel(
                 resource,
                 selection.selection.interpreter,
+                type,
                 undefined,
                 session,
                 false,
@@ -371,6 +386,7 @@ export class KernelSelector {
     private async useInterpreterAsKernel(
         resource: Resource,
         interpreter: PythonInterpreter,
+        type: 'raw' | 'jupyter' | 'noConnection',
         displayNameOfKernelNotFound?: string,
         session?: IJupyterSessionManager,
         disableUI?: boolean,
@@ -426,7 +442,7 @@ export class KernelSelector {
 
         // When this method is called, we know a new kernel may have been registered.
         // Lets pre-warm the list of local kernels (with the new list).
-        this.selectionProvider.getKernelSelectionsForLocalSession(resource, session, cancelToken).ignoreErrors();
+        this.selectionProvider.getKernelSelectionsForLocalSession(resource, type, session, cancelToken).ignoreErrors();
 
         return { kernelSpec, interpreter };
     }

src/client/datascience/jupyter/kernels/kernelSwitcher.ts

@@ -43,6 +43,7 @@ export class KernelSwitcher {
 
     public async askForLocalKernel(
         resource: Resource,
+        type: 'raw' | 'jupyter' | 'noConnection',
         kernelSpec: IJupyterKernelSpec | LiveKernelModel | undefined
     ): Promise<KernelSpecInterpreter | undefined> {
         const displayName = kernelSpec?.display_name || kernelSpec?.name || '';
@@ -51,7 +52,7 @@ export class KernelSwitcher {
         const cancel = Common.cancel();
         const selection = await this.appShell.showErrorMessage(message, selectKernel, cancel);
         if (selection === selectKernel) {
-            return this.selectLocalJupyterKernel(resource, kernelSpec);
+            return this.selectLocalJupyterKernel(resource, type, kernelSpec);
         }
     }
 
@@ -64,7 +65,11 @@ export class KernelSwitcher {
             settings.datascience.jupyterServerURI.toLowerCase() === Settings.JupyterServerLocalLaunch;
 
         if (isLocalConnection) {
-            kernel = await this.selectLocalJupyterKernel(notebook.resource, notebook?.getKernelSpec());
+            kernel = await this.selectLocalJupyterKernel(
+                notebook.resource,
+                notebook.connection?.type || 'noConnection',
+                notebook?.getKernelSpec()
+            );
         } else if (notebook) {
             const connInfo = notebook.connection;
             const currentKernel = notebook.getKernelSpec();
@@ -77,9 +82,17 @@ export class KernelSwitcher {
 
     private async selectLocalJupyterKernel(
         resource: Resource,
+        type: 'raw' | 'jupyter' | 'noConnection',
         currentKernel?: IJupyterKernelSpec | LiveKernelModel
     ): Promise<KernelSpecInterpreter> {
-        return this.kernelSelector.selectLocalKernel(resource, new StopWatch(), undefined, undefined, currentKernel);
+        return this.kernelSelector.selectLocalKernel(
+            resource,
+            type,
+            new StopWatch(),
+            undefined,
+            undefined,
+            currentKernel
+        );
     }
 
     private async selectRemoteJupyterKernel(
@@ -119,6 +132,7 @@ export class KernelSwitcher {
                     // At this point we have a valid jupyter server.
                     const potential = await this.askForLocalKernel(
                         notebook.resource,
+                        notebook.connection?.type || 'noConnection',
                         kernel.kernelSpec || kernel.kernelModel
                     );
                     if (potential && Object.keys(potential).length > 0) {

src/client/datascience/kernel-launcher/kernelFinder.ts

@@ -107,6 +107,11 @@ export class KernelFinder implements IKernelFinder {
         return this.verifyIpyKernel(foundKernel, cancelToken);
     }
 
+    // Search all our local file system locations for installed kernel specs and return them
+    public async listKernelSpecs(_cancelToken?: CancellationToken): Promise<IJupyterKernelSpec[]> {
+        throw new Error('Not yet implmented');
+    }
+
     // For the given kernelspec return back the kernelspec with ipykernel installed into it or error
     private async verifyIpyKernel(
         kernelSpec: IJupyterKernelSpec,

src/client/datascience/kernel-launcher/types.ts

@@ -49,6 +49,7 @@ export interface IKernelFinder {
         kernelName?: string,
         cancelToken?: CancellationToken
     ): Promise<IJupyterKernelSpec>;
+    listKernelSpecs(cancelToken?: CancellationToken): Promise<IJupyterKernelSpec[]>;
 }
 
 /**

src/test/datascience/jupyter/kernels/kernelSelections.unit.test.ts

@@ -16,6 +16,7 @@ import { JupyterSessionManager } from '../../../../client/datascience/jupyter/ju
 import { KernelSelectionProvider } from '../../../../client/datascience/jupyter/kernels/kernelSelections';
 import { KernelService } from '../../../../client/datascience/jupyter/kernels/kernelService';
 import { IKernelSpecQuickPickItem } from '../../../../client/datascience/jupyter/kernels/types';
+import { IKernelFinder } from '../../../../client/datascience/kernel-launcher/types';
 import { IJupyterKernel, IJupyterKernelSpec, IJupyterSessionManager } from '../../../../client/datascience/types';
 import { InterpreterSelector } from '../../../../client/interpreter/configuration/interpreterSelector/interpreterSelector';
 import { IInterpreterQuickPickItem, IInterpreterSelector } from '../../../../client/interpreter/configuration/types';
@@ -25,6 +26,7 @@ import { InterpreterType } from '../../../../client/interpreter/contracts';
 suite('Data Science - KernelSelections', () => {
     let kernelSelectionProvider: KernelSelectionProvider;
     let kernelService: KernelService;
+    let kernelFinder: IKernelFinder;
     let interpreterSelector: IInterpreterSelector;
     let pathUtils: IPathUtils;
     let fs: IFileSystem;
@@ -132,6 +134,7 @@ suite('Data Science - KernelSelections', () => {
         interpreterSelector = mock(InterpreterSelector);
         sessionManager = mock(JupyterSessionManager);
         kernelService = mock(KernelService);
+        kernelFinder = mock<IKernelFinder>();
         fs = mock(FileSystem);
         pathUtils = mock(PathUtils);
         when(pathUtils.getDisplayName(anything())).thenReturn('<user friendly path>');
@@ -140,7 +143,8 @@ suite('Data Science - KernelSelections', () => {
             instance(kernelService),
             instance(interpreterSelector),
             instance(fs),
-            instance(pathUtils)
+            instance(pathUtils),
+            instance(kernelFinder)
         );
     });
 
@@ -216,7 +220,44 @@ suite('Data Science - KernelSelections', () => {
         verify(sessionManager.getKernelSpecs()).once();
         assert.deepEqual(items, expectedItems);
     });
-    test('Should return a list of Local Kernels + Interpreters for local connection (excluding non-python kernels)', async () => {
+    test('Should return a list of Local Kernels + Interpreters for local raw connection (excluding non-python kernels)', async () => {
+        when(kernelFinder.listKernelSpecs(anything())).thenResolve(allSpecs);
+        when(interpreterSelector.getSuggestions(undefined)).thenResolve(allInterpreters);
+
+        // Quick pick must contain
+        // - kernel spec display name
+        // - selection = kernel model + kernel spec
+        // - description = last activity and # of connections.
+        const expectedKernelItems: IKernelSpecQuickPickItem[] = [python1KernelSpecModel, python3KernelSpecModel].map(
+            (item) => {
+                return {
+                    label: item.display_name,
+                    detail: '<user friendly path>',
+                    selection: { interpreter: undefined, kernelModel: undefined, kernelSpec: item }
+                };
+            }
+        );
+        const expectedInterpreterItems: IKernelSpecQuickPickItem[] = allInterpreters.map((item) => {
+            return {
+                ...item,
+                label: item.label,
+                detail: '<user friendly path>',
+                description: '',
+                selection: { kernelModel: undefined, interpreter: item.interpreter, kernelSpec: undefined }
+            };
+        });
+        const expectedList = [...expectedKernelItems, ...expectedInterpreterItems];
+        expectedList.sort((a, b) => (a.label === b.label ? 0 : a.label > b.label ? 1 : -1));
+
+        const items = await kernelSelectionProvider.getKernelSelectionsForLocalSession(
+            undefined,
+            'raw',
+            instance(sessionManager)
+        );
+
+        assert.deepEqual(items, expectedList);
+    });
+    test('Should return a list of Local Kernels + Interpreters for local jupyter connection (excluding non-python kernels)', async () => {
         when(sessionManager.getKernelSpecs()).thenResolve(allSpecs);
         when(kernelService.getKernelSpecs(anything(), anything())).thenResolve(allSpecs);
         when(interpreterSelector.getSuggestions(undefined)).thenResolve(allInterpreters);
@@ -248,6 +289,7 @@ suite('Data Science - KernelSelections', () => {
 
         const items = await kernelSelectionProvider.getKernelSelectionsForLocalSession(
             undefined,
+            'jupyter',
             instance(sessionManager)
         );