Notify for failed notebook cell executions

Author: mwakaba2

README.md

@@ -14,14 +14,15 @@ Notebook Cell Completion Browser Notifications for JupyterLab.
 
 * Web Browser that supports the Notification Web API (See [Browser Compatibility Chart](https://developer.mozilla.org/en-US/docs/Web/API/notification#browser_compatibility))
 * JupyterLab >= 3.0
-* Notebook Cell Timing needs to be enabled for Jupyterlab Notifications to work. Please go to Settings -> Advanced Settings Editor -> Notebook and update setting to:
+* Notebook Cell Timing needs to be enabled for Jupyterlab Notifications with version < `0.3.0` to work. Please go to Settings -> Advanced Settings Editor -> Notebook and update setting to:
 ```json5
 {
   // Recording timing
   // Should timing data be recorded in cell metadata
   "recordTiming": true
 }
 ```
+* [BETA] the cell timing doesn't need to be enabled for Jupyterlab >= 3.1 and Jupyterlab notification version 0.3.0.
 
 ## Install
 

package.json

@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@jupyterlab/application": "^3.0.6",
-    "@jupyterlab/notebook": "^3.0.6",
+    "@jupyterlab/notebook": "^3.1.0-beta.1",
     "@jupyterlab/settingregistry": "^3.0.3"
   },
   "devDependencies": {

src/index.ts

@@ -2,25 +2,13 @@ import {
   JupyterFrontEnd,
   JupyterFrontEndPlugin
 } from '@jupyterlab/application';
-import { NotebookActions } from '@jupyterlab/notebook';
-import { IObservableJSON } from '@jupyterlab/observables';
+import { KernelError, Notebook, NotebookActions } from '@jupyterlab/notebook';
+import { Cell } from '@jupyterlab/cells';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ICodeCellModel } from '@jupyterlab/cells';
 
 import { checkBrowserNotificationSettings } from './settings';
 
-/**
- * Extracts Code Cell Start and End Time
- */
-function extractExecutionMetadata(metadata: IObservableJSON): [Date, Date] {
-  const executionMetadata = Object.assign({}, metadata.get('execution') as any);
-  const cellStartTime = new Date(
-    executionMetadata['shell.execute_reply.started'] ||
-      executionMetadata['iopub.execute_input']
-  );
-  const cellEndTime = new Date(executionMetadata['shell.execute_reply']);
-  return [cellStartTime, cellEndTime];
-}
 
 /**
  * Constructs notification message and displays it.
@@ -30,14 +18,20 @@ function displayNotification(
   cellNumber: number,
   notebookName: string,
   reportCellNumber: boolean,
-  reportCellExecutionTime: boolean
+  reportCellExecutionTime: boolean,
+  failedExecution: boolean,
+  error: KernelError | null
 ): void {
   const notificationPayload = {
     icon: '/static/favicon.ico',
     body: ''
   };
+  const title = failedExecution ? `${notebookName} Failed!` : `${notebookName} Completed!`;
   let message = '';
-  if (reportCellNumber && reportCellExecutionTime) {
+
+  if (failedExecution) {
+    message = error ? `${error.errorName} ${error.errorValue}` : '';
+  } else if (reportCellNumber && reportCellExecutionTime) {
     message = `Cell[${cellNumber}] Duration: ${cellDuration}`;
   } else if (reportCellNumber) {
     message = `Cell Number: ${cellNumber}`;
@@ -46,20 +40,65 @@ function displayNotification(
   }
 
   notificationPayload.body = message;
-  new Notification(`${notebookName} Cell Completed!`, notificationPayload);
+  new Notification(title, notificationPayload);
+}
+
+/**
+ * Trigger notification.
+ */
+function triggerNotification(
+  cell: Cell,
+  notebook: Notebook,
+  cellStartTime: Date,
+  cellEndTime: Date,
+  minimumCellExecutionTime: number,
+  reportCellNumber: boolean,
+  reportCellExecutionTime: boolean,
+  cellNumberType: string,
+  failedExecution: boolean,
+  error: KernelError | null
+) {
+  const codeCell = cell.model.type === 'code';
+  const nonEmptyCell = cell.model.value.text.length > 0;
+  if (codeCell && nonEmptyCell) {
+    const codeCellModel = cell.model as ICodeCellModel;
+    const diff = new Date(<any>cellEndTime - <any>cellStartTime);
+    const diffSeconds = Math.floor(diff.getTime() / 1000);
+    if (diffSeconds >= minimumCellExecutionTime) {
+      const cellDuration = diff.toISOString().substr(11, 8);
+      const cellNumber =
+        cellNumberType === 'cell_index'
+          ? notebook.activeCellIndex
+          : codeCellModel.executionCount;
+      const notebookName = notebook.title.label.replace(
+        /\.[^/.]+$/,
+        ''
+      );
+      displayNotification(
+        cellDuration,
+        cellNumber,
+        notebookName,
+        reportCellNumber,
+        reportCellExecutionTime,
+        failedExecution, 
+        error
+      );
+    }
+  }
 }
 
 const extension: JupyterFrontEndPlugin<void> = {
   id: 'jupyterlab-notifications:plugin',
   autoStart: true,
-  optional: [ISettingRegistry],
+  requires: [ISettingRegistry],
   activate: async (app: JupyterFrontEnd, settingRegistry: ISettingRegistry) => {
     checkBrowserNotificationSettings();
     let enabled = true;
     let minimumCellExecutionTime = 60;
     let reportCellExecutionTime = true;
     let reportCellNumber = true;
     let cellNumberType = 'cell_index';
+
     if (settingRegistry) {
       const setting = await settingRegistry.load(extension.id);
       const updateSettings = (): void => {
@@ -70,51 +109,35 @@ const extension: JupyterFrontEndPlugin<void> = {
           .composite as boolean;
         reportCellNumber = setting.get('report_cell_number')
           .composite as boolean;
-        cellNumberType = setting.get('cell_number_type').composite as string;
+        cellNumberType = setting.get('cell_number_type')
+          .composite as string;
       };
       updateSettings();
       setting.changed.connect(updateSettings);
     }
 
+    let cellStartTime = new Date();
+
+    NotebookActions.executionScheduled.connect((_, args) => {
+      if (enabled) {
+        cellStartTime = new Date();
+      }
+    });
+
     NotebookActions.executed.connect((_, args) => {
       if (enabled) {
-        const { cell, notebook } = args;
-        const codeCell = cell.model.type === 'code';
-        const nonEmptyCell = cell.model.value.text.length > 0;
-        const metadata = cell.model.metadata;
-        if (codeCell && nonEmptyCell) {
-          const codeCellModel = cell.model as ICodeCellModel;
-          if (metadata.has('execution')) {
-            const [cellStartTime, cellEndTime] = extractExecutionMetadata(
-              metadata
-            );
-            const diff = new Date(<any>cellEndTime - <any>cellStartTime);
-            const diffSeconds = Math.floor(diff.getTime() / 1000);
-            if (diffSeconds >= minimumCellExecutionTime) {
-              const cellDuration = diff.toISOString().substr(11, 8);
-              const cellNumber =
-                cellNumberType === 'cell_index'
-                  ? notebook.activeCellIndex
-                  : codeCellModel.executionCount;
-              const notebookName = notebook.title.label.replace(
-                /\.[^/.]+$/,
-                ''
-              );
-              displayNotification(
-                cellDuration,
-                cellNumber,
-                notebookName,
-                reportCellNumber,
-                reportCellExecutionTime
-              );
-            }
-          } else {
-            alert(
-              'Notebook Cell Timing needs to be enabled for Jupyterlab Notifications to work. ' +
-                'Please go to Settings -> Advanced Settings Editor -> Notebook and update setting to {"recordTiming": true}'
-            );
-          }
-        }
+        const { cell, notebook, success, error } = args;
+        const cellEndTime = new Date();
+        triggerNotification(cell, 
+                            notebook, 
+                            cellStartTime,
+                            cellEndTime,
+                            minimumCellExecutionTime, 
+                            reportCellNumber, 
+                            reportCellExecutionTime,
+                            cellNumberType,
+                            !success,
+                            error);
       }
     });
   }