Run kernel on cell execution when no kernel

docs/source/extension/extension_migration.rst

@@ -32,6 +32,7 @@ bumped their major version (following semver convention). We want to point out p
    * Rename ``IToolbarWidgetRegistry.registerFactory`` to ``IToolbarWidgetRegistry.addFactory``
    * ``ISanitizer`` and ``ISanitizer.IOptions`` are deprecated in favor of ``IRenderMime.ISanitizer`` and
      ``IRenderMime.ISanitizerOptions`` in ``@jupyterlab/rendermime-interfaces``.
+   * Global ``sessionContextDialogs`` is removed; you should request the token ``ISessionContextDialogs`` (from ``@jupyterlab/apputils``).
 - ``@jupyterlab/attachments`` from 3.x to 4.x
    Removed ``modelDB`` from ``IAttachmentsModel.IOptions``.
 - ``@jupyterlab/buildutils`` from 3.x to 4.x
@@ -196,6 +197,7 @@ bumped their major version (following semver convention). We want to point out p
    * ``IMainMenu.addMenu`` signature changed from ``addMenu(menu: Menu, options?: IMainMenu.IAddOptions): void``
      to ``addMenu(menu: Menu, update?: boolean, options?: IMainMenu.IAddOptions): void``
 - ``@jupyterlab/notebook`` from 3.x to 4.x
+   * ``NotebookWidgetFactory.IOptions`` has no ``sessionDialogs`` option any more.
    * The ``NotebookPanel._onSave`` method is now ``private``.
    * ``NotebookActions.collapseAll`` method renamed to ``NotebookActions.collapseAllHeadings``.
    * Command ``Collapsible_Headings:Toggle_Collapse`` renamed to ``notebook:toggle-heading-collapse``.

examples/cell/src/index.ts

@@ -13,8 +13,17 @@ import '@jupyterlab/theme-light-extension/style/theme.css';
 import '@jupyterlab/completer/style/index.css';
 import '../index.css';
 
-import { Toolbar as AppToolbar, SessionContext } from '@jupyterlab/apputils';
-import { Toolbar } from '@jupyterlab/ui-components';
+import {
+  Toolbar as AppToolbar,
+  SessionContext,
+  SessionContextDialogs
+} from '@jupyterlab/apputils';
+import {
+  refreshIcon,
+  stopIcon,
+  Toolbar,
+  ToolbarButton
+} from '@jupyterlab/ui-components';
 
 import { Cell, CodeCell, CodeCellModel } from '@jupyterlab/cells';
 
@@ -138,10 +147,29 @@ function main(): void {
   toolbar.addItem('spacer', Toolbar.createSpacerItem());
   toolbar.addItem(
     'interrupt',
-    AppToolbar.createInterruptButton(sessionContext)
+    new ToolbarButton({
+      icon: stopIcon,
+      onClick: () => {
+        void sessionContext.session?.kernel?.interrupt();
+      },
+      tooltip: 'Interrupt the kernel'
+    })
+  );
+  const dialogs = new SessionContextDialogs();
+  toolbar.addItem(
+    'restart',
+    new ToolbarButton({
+      icon: refreshIcon,
+      onClick: () => {
+        void dialogs.restart(sessionContext);
+      },
+      tooltip: 'Restart the kernel'
+    })
+  );
+  toolbar.addItem(
+    'name',
+    AppToolbar.createKernelNameItem(sessionContext, dialogs)
   );
-  toolbar.addItem('restart', AppToolbar.createRestartButton(sessionContext));
-  toolbar.addItem('name', AppToolbar.createKernelNameItem(sessionContext));
   toolbar.addItem('status', AppToolbar.createKernelStatusItem(sessionContext));
 
   // Lay out the widgets.

examples/notebook/src/commands.ts

@@ -6,7 +6,7 @@
 /**
  * Set up keyboard shortcuts & commands for notebook
  */
-import { sessionContextDialogs } from '@jupyterlab/apputils';
+import { SessionContextDialogs } from '@jupyterlab/apputils';
 import { CompletionHandler } from '@jupyterlab/completer';
 import {
   SearchDocumentModel,
@@ -163,6 +163,7 @@ export const SetupCommands = (
     execute: async () =>
       nbWidget.context.sessionContext.session?.kernel?.interrupt()
   });
+  const sessionContextDialogs = new SessionContextDialogs();
   commands.addCommand(cmdIds.restart, {
     label: 'Restart Kernel',
     execute: () =>
@@ -178,7 +179,8 @@ export const SetupCommands = (
     execute: () => {
       return NotebookActions.runAndAdvance(
         nbWidget.content,
-        nbWidget.context.sessionContext
+        nbWidget.context.sessionContext,
+        sessionContextDialogs
       );
     }
   });
@@ -187,7 +189,8 @@ export const SetupCommands = (
     execute: () => {
       return NotebookActions.run(
         nbWidget.content,
-        nbWidget.context.sessionContext
+        nbWidget.context.sessionContext,
+        sessionContextDialogs
       );
     }
   });

galata/test/jupyterlab/kernel.test.ts

@@ -0,0 +1,140 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { expect, test } from '@jupyterlab/galata';
+
+test.describe('Kernel', () => {
+  test.describe('Notebook', () => {
+    test('Should not ask kernel when creating notebook from launcher', async ({
+      page
+    }) => {
+      await Promise.all([
+        page
+          .getByRole('tabpanel', { name: 'Launcher' })
+          .waitFor({ state: 'detached' }),
+        page.getByTitle('Python 3 (ipykernel)').nth(1).click()
+      ]);
+
+      await expect.soft(page.locator('.jp-Dialog')).toHaveCount(0);
+
+      await expect(page.getByTitle('Switch kernel')).toHaveText(
+        'Python 3 (ipykernel)'
+      );
+    });
+
+    test('Should remember kernel auto start for notebook', async ({ page }) => {
+      await page.menu.clickMenuItem('File>New>Notebook');
+
+      // Open a notebook without selecting a kernel
+      await page
+        .locator('.jp-Dialog')
+        .getByRole('button', { name: 'No Kernel' })
+        .click();
+
+      await expect
+        .soft(page.getByTitle('Switch kernel'))
+        .toHaveText('No Kernel');
+
+      await Promise.all([
+        page
+          .getByRole('tab', { name: 'Untitled.ipynb' })
+          .waitFor({ state: 'detached' }),
+        page.menu.clickMenuItem('File>Close Tab')
+      ]);
+
+      // Open the same notebook selecting and turning on auto start
+      await page.filebrowser.open('Untitled.ipynb');
+
+      await page
+        .locator('.jp-Dialog')
+        .getByText('Always start the preferred kernel')
+        .click();
+      await page
+        .locator('.jp-Dialog')
+        .getByRole('button', { name: 'Select' })
+        .click();
+
+      await expect
+        .soft(page.getByTitle('Switch kernel'))
+        .toHaveText('Python 3 (ipykernel)');
+
+      await page.menu.clickMenuItem('File>Close and Shut Down Notebook');
+
+      await Promise.all([
+        page
+          .getByRole('tab', { name: 'Untitled.ipynb' })
+          .waitFor({ state: 'detached' }),
+        page.locator('.jp-Dialog').getByRole('button', { name: 'Ok' }).click()
+      ]);
+
+      // Open the same notebook and check it turns on the kernel
+      await page.filebrowser.open('Untitled.ipynb');
+
+      await expect(page.getByTitle('Switch kernel')).toHaveText(
+        'Python 3 (ipykernel)'
+      );
+    });
+
+    test('Should request kernel selection when executing a cell for notebook without kernel', async ({
+      page
+    }) => {
+      await page.menu.clickMenuItem('File>New>Notebook');
+
+      // Open a notebook without selecting a kernel
+      await page
+        .locator('.jp-Dialog')
+        .getByRole('button', { name: 'No Kernel' })
+        .click();
+
+      await expect
+        .soft(page.getByTitle('Switch kernel'))
+        .toHaveText('No Kernel');
+
+      // Request cell execution
+      await page.menu.clickMenuItem('Run>Run Selected Cell');
+
+      await page
+        .locator('.jp-Dialog')
+        .getByRole('button', { name: 'Select' })
+        .click();
+
+      await expect(page.getByTitle('Switch kernel')).toHaveText(
+        'Python 3 (ipykernel)'
+      );
+    });
+  });
+
+  test.describe('Console', () => {
+    test('Should not ask kernel when creating console from launcher', async ({
+      page
+    }) => {
+      await Promise.all([
+        page
+          .getByRole('tabpanel', { name: 'Launcher' })
+          .waitFor({ state: 'detached' }),
+        page.getByTitle('Python 3 (ipykernel)').nth(2).click()
+      ]);
+
+      await expect.soft(page.locator('.jp-Dialog')).toHaveCount(0);
+
+      await expect(page.getByTitle('Change kernel for Console 1')).toHaveText(
+        'Python 3 (ipykernel) | Idle'
+      );
+    });
+
+    test('Should ask for kernel when creating console from menu', async ({
+      page
+    }) => {
+      await page.menu.clickMenuItem('File>New>Console');
+
+      await page
+        .locator('.jp-Dialog')
+        .getByRole('button', { name: 'Select' })
+        .click();
+
+      await expect(page.getByTitle('Change kernel for Console 1')).toHaveText(
+        'Python 3 (ipykernel) | Idle'
+      );
+    });
+  });
+});

packages/apputils-extension/src/index.ts

@@ -23,13 +23,13 @@ import {
   MainAreaWidget,
   Printing,
   Sanitizer,
-  sessionContextDialogs,
+  SessionContextDialogs,
   WindowResolver
 } from '@jupyterlab/apputils';
 import { PageConfig, PathExt, URLExt } from '@jupyterlab/coreutils';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { IStateDB, StateDB } from '@jupyterlab/statedb';
-import { ITranslator } from '@jupyterlab/translation';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { jupyterFaviconIcon } from '@jupyterlab/ui-components';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { DisposableDelegate } from '@lumino/disposable';
@@ -555,9 +555,12 @@ const state: JupyterFrontEndPlugin<IStateDB> = {
 const sessionDialogs: JupyterFrontEndPlugin<ISessionContextDialogs> = {
   id: '@jupyterlab/apputils-extension:sessionDialogs',
   provides: ISessionContextDialogs,
+  optional: [ITranslator],
   autoStart: true,
-  activate: () => {
-    return sessionContextDialogs;
+  activate: async (app: JupyterFrontEnd, translator: ITranslator | null) => {
+    return new SessionContextDialogs({
+      translator: translator ?? nullTranslator
+    });
   }
 };
 

packages/apputils-extension/src/statusbarplugin.ts

@@ -14,10 +14,10 @@ import {
   ISessionContextDialogs,
   KernelStatus,
   RunningSessions,
-  sessionContextDialogs
+  SessionContextDialogs
 } from '@jupyterlab/apputils';
 import { IStatusBar } from '@jupyterlab/statusbar';
-import { ITranslator } from '@jupyterlab/translation';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { Title, Widget } from '@lumino/widgets';
 
 /**
@@ -26,26 +26,26 @@ import { Title, Widget } from '@lumino/widgets';
 export const kernelStatus: JupyterFrontEndPlugin<IKernelStatusModel> = {
   id: '@jupyterlab/apputils-extension:kernel-status',
   autoStart: true,
-  requires: [IStatusBar, ITranslator],
+  requires: [IStatusBar],
   provides: IKernelStatusModel,
-  optional: [ISessionContextDialogs, ILabShell],
+  optional: [ISessionContextDialogs, ITranslator, ILabShell],
   activate: (
     app: JupyterFrontEnd,
     statusBar: IStatusBar,
-    translator: ITranslator,
-    sessionDialogs: ISessionContextDialogs | null,
+    sessionDialogs_: ISessionContextDialogs | null,
+    translator_: ITranslator | null,
     labShell: ILabShell | null
   ): IKernelStatusModel => {
+    const translator = translator_ ?? nullTranslator;
+    const sessionDialogs =
+      sessionDialogs_ ?? new SessionContextDialogs({ translator });
     // When the status item is clicked, launch the kernel
     // selection dialog for the current session.
     const changeKernel = async () => {
       if (!item.model.sessionContext) {
         return;
       }
-      await (sessionDialogs ?? sessionContextDialogs).selectKernel(
-        item.model.sessionContext,
-        translator
-      );
+      await sessionDialogs.selectKernel(item.model.sessionContext);
     };
 
     // Create the status item.