// Copyright (c) Jupyter Development Team. // Distributed under the terms of the Modified BSD License. import { JupyterFrontEnd, JupyterFrontEndPlugin, } from '@jupyterlab/application'; import { ISessionContext, DOMUtils, IToolbarWidgetRegistry, } from '@jupyterlab/apputils'; import { Cell, CodeCell } from '@jupyterlab/cells'; import { Text, Time } from '@jupyterlab/coreutils'; import { IDocumentManager } from '@jupyterlab/docmanager'; import { IMainMenu } from '@jupyterlab/mainmenu'; import { NotebookPanel, INotebookTracker, INotebookTools, } from '@jupyterlab/notebook'; import { ISettingRegistry } from '@jupyterlab/settingregistry'; import { ITranslator, nullTranslator } from '@jupyterlab/translation'; import { INotebookShell } from '@jupyter-notebook/application'; import { Poll } from '@lumino/polling'; import { Widget } from '@lumino/widgets'; import { TrustedComponent } from './trusted'; /** * The class for kernel status errors. */ const KERNEL_STATUS_ERROR_CLASS = 'jp-NotebookKernelStatus-error'; /** * The class for kernel status warnings. */ const KERNEL_STATUS_WARN_CLASS = 'jp-NotebookKernelStatus-warn'; /** * The class for kernel status infos. */ const KERNEL_STATUS_INFO_CLASS = 'jp-NotebookKernelStatus-info'; /** * The class to fade out the kernel status. */ const KERNEL_STATUS_FADE_OUT_CLASS = 'jp-NotebookKernelStatus-fade'; /** * The class for scrolled outputs */ const SCROLLED_OUTPUTS_CLASS = 'jp-mod-outputsScrolled'; /** * A plugin for the checkpoint indicator */ const checkpoints: JupyterFrontEndPlugin = { id: '@jupyter-notebook/notebook-extension:checkpoints', autoStart: true, requires: [IDocumentManager, ITranslator], optional: [INotebookShell, IToolbarWidgetRegistry], activate: ( app: JupyterFrontEnd, docManager: IDocumentManager, translator: ITranslator, notebookShell: INotebookShell | null, toolbarRegistry: IToolbarWidgetRegistry | null ) => { const { shell } = app; const trans = translator.load('notebook'); const node = document.createElement('div'); if (toolbarRegistry) { toolbarRegistry.addFactory('TopBar', 'checkpoint', (toolbar) => { const widget = new Widget({ node }); widget.id = DOMUtils.createDomID(); widget.addClass('jp-NotebookCheckpoint'); return widget; }); } const onChange = async () => { const current = shell.currentWidget; if (!current) { return; } const context = docManager.contextForWidget(current); context?.fileChanged.disconnect(onChange); context?.fileChanged.connect(onChange); const checkpoints = await context?.listCheckpoints(); if (!checkpoints) { return; } const checkpoint = checkpoints[checkpoints.length - 1]; node.textContent = trans.__( 'Last Checkpoint: %1', Time.formatHuman(new Date(checkpoint.last_modified)) ); }; if (notebookShell) { notebookShell.currentChanged.connect(onChange); } new Poll({ auto: true, factory: () => onChange(), frequency: { interval: 2000, backoff: false, }, standby: 'when-hidden', }); }, }; /** * Add a command to close the browser tab when clicking on "Close and Shut Down" */ const closeTab: JupyterFrontEndPlugin = { id: '@jupyter-notebook/notebook-extension:close-tab', autoStart: true, requires: [IMainMenu], optional: [ITranslator], activate: ( app: JupyterFrontEnd, menu: IMainMenu, translator: ITranslator | null ) => { const { commands } = app; translator = translator ?? nullTranslator; const trans = translator.load('notebook'); const id = 'notebook:close-and-halt'; commands.addCommand(id, { label: trans.__('Close and Shut Down Notebook'), execute: async () => { await commands.execute('notebook:close-and-shutdown'); window.close(); }, }); menu.fileMenu.closeAndCleaners.add({ id, // use a small rank to it takes precedence over the default // shut down action for the notebook rank: 0, }); }, }; /** * The kernel logo plugin. */ const kernelLogo: JupyterFrontEndPlugin = { id: '@jupyter-notebook/notebook-extension:kernel-logo', autoStart: true, requires: [INotebookShell], optional: [IToolbarWidgetRegistry], activate: ( app: JupyterFrontEnd, shell: INotebookShell, toolbarRegistry: IToolbarWidgetRegistry | null ) => { const { serviceManager } = app; const node = document.createElement('div'); const img = document.createElement('img'); const onChange = async () => { const current = shell.currentWidget; if (!(current instanceof NotebookPanel)) { return; } if (!node.hasChildNodes()) { node.appendChild(img); } await current.sessionContext.ready; current.sessionContext.kernelChanged.disconnect(onChange); current.sessionContext.kernelChanged.connect(onChange); const name = current.sessionContext.session?.kernel?.name ?? ''; const spec = serviceManager.kernelspecs?.specs?.kernelspecs[name]; if (!spec) { node.childNodes[0].remove(); return; } const kernelIconUrl = spec.resources['logo-64x64']; if (!kernelIconUrl) { node.childNodes[0].remove(); return; } img.src = kernelIconUrl; img.title = spec.display_name; }; if (toolbarRegistry) { toolbarRegistry.addFactory('TopBar', 'kernelLogo', (toolbar) => { const widget = new Widget({ node }); widget.addClass('jp-NotebookKernelLogo'); return widget; }); } app.started.then(() => { shell.currentChanged.connect(onChange); }); }, }; /** * A plugin to display the kernel status; */ const kernelStatus: JupyterFrontEndPlugin = { id: '@jupyter-notebook/notebook-extension:kernel-status', autoStart: true, requires: [INotebookShell, ITranslator], activate: ( app: JupyterFrontEnd, shell: INotebookShell, translator: ITranslator ) => { const trans = translator.load('notebook'); const widget = new Widget(); widget.addClass('jp-NotebookKernelStatus'); app.shell.add(widget, 'menu', { rank: 10_010 }); const removeClasses = () => { widget.removeClass(KERNEL_STATUS_ERROR_CLASS); widget.removeClass(KERNEL_STATUS_WARN_CLASS); widget.removeClass(KERNEL_STATUS_INFO_CLASS); widget.removeClass(KERNEL_STATUS_FADE_OUT_CLASS); }; const onStatusChanged = (sessionContext: ISessionContext) => { const status = sessionContext.kernelDisplayStatus; let text = `Kernel ${Text.titleCase(status)}`; removeClasses(); switch (status) { case 'busy': case 'idle': text = ''; widget.addClass(KERNEL_STATUS_FADE_OUT_CLASS); break; case 'dead': case 'terminating': widget.addClass(KERNEL_STATUS_ERROR_CLASS); break; case 'unknown': widget.addClass(KERNEL_STATUS_WARN_CLASS); break; default: widget.addClass(KERNEL_STATUS_INFO_CLASS); widget.addClass(KERNEL_STATUS_FADE_OUT_CLASS); break; } widget.node.textContent = trans.__(text); }; const onChange = async () => { const current = shell.currentWidget; if (!(current instanceof NotebookPanel)) { return; } const sessionContext = current.sessionContext; sessionContext.statusChanged.connect(onStatusChanged); }; shell.currentChanged.connect(onChange); }, }; /** * A plugin to enable scrolling for outputs by default. * Mimic the logic from the classic notebook, as found here: * https://github.com/jupyter/notebook/blob/a9a31c096eeffe1bff4e9164c6a0442e0e13cdb3/notebook/static/notebook/js/outputarea.js#L96-L120 */ const scrollOutput: JupyterFrontEndPlugin = { id: '@jupyter-notebook/notebook-extension:scroll-output', autoStart: true, requires: [INotebookTracker], optional: [ISettingRegistry], activate: async ( app: JupyterFrontEnd, tracker: INotebookTracker, settingRegistry: ISettingRegistry | null ) => { const autoScrollThreshold = 100; let autoScrollOutputs = true; // decide whether to scroll the output of the cell based on some heuristics const autoScroll = (cell: CodeCell) => { if (!autoScrollOutputs) { // bail if disabled via the settings return; } const { outputArea } = cell; // respect cells with an explicit scrolled state const scrolled = cell.model.getMetadata('scrolled'); if (scrolled !== undefined) { return; } const { node } = outputArea; const height = node.scrollHeight; const fontSize = parseFloat(node.style.fontSize.replace('px', '')); const lineHeight = (fontSize || 14) * 1.3; // do not set via cell.outputScrolled = true, as this would // otherwise synchronize the scrolled state to the notebook metadata const scroll = height > lineHeight * autoScrollThreshold; cell.toggleClass(SCROLLED_OUTPUTS_CLASS, scroll); }; const handlers: { [id: string]: () => void } = {}; const setAutoScroll = (cell: Cell) => { if (cell.model.type === 'code') { const codeCell = cell as CodeCell; const id = codeCell.model.id; autoScroll(codeCell); if (handlers[id]) { codeCell.outputArea.model.changed.disconnect(handlers[id]); } handlers[id] = () => autoScroll(codeCell); codeCell.outputArea.model.changed.connect(handlers[id]); } }; tracker.widgetAdded.connect((sender, notebook) => { // when the notebook widget is created, process all the cells notebook.sessionContext.ready.then(() => { notebook.content.widgets.forEach(setAutoScroll); }); notebook.model?.cells.changed.connect((sender, args) => { notebook.content.widgets.forEach(setAutoScroll); }); }); if (settingRegistry) { const loadSettings = settingRegistry.load(scrollOutput.id); const updateSettings = (settings: ISettingRegistry.ISettings): void => { autoScrollOutputs = settings.get('autoScrollOutputs') .composite as boolean; }; Promise.all([loadSettings, app.restored]) .then(([settings]) => { updateSettings(settings); settings.changed.connect((settings) => { updateSettings(settings); }); }) .catch((reason: Error) => { console.error(reason.message); }); } }, }; /** * A plugin to add the NotebookTools to the side panel; */ const notebookToolsWidget: JupyterFrontEndPlugin = { id: '@jupyter-notebook/notebook-extension:notebook-tools', autoStart: true, requires: [INotebookShell], optional: [INotebookTools], activate: ( app: JupyterFrontEnd, shell: INotebookShell, notebookTools: INotebookTools | null ) => { const onChange = async () => { const current = shell.currentWidget; if (!(current instanceof NotebookPanel)) { return; } // Add the notebook tools in right area. if (notebookTools) { shell.add(notebookTools, 'right', { type: 'Property Inspector' }); } }; shell.currentChanged.connect(onChange); }, }; /** * A plugin that adds a Trusted indicator to the menu area */ const trusted: JupyterFrontEndPlugin = { id: '@jupyter-notebook/notebook-extension:trusted', autoStart: true, requires: [INotebookShell, ITranslator], activate: ( app: JupyterFrontEnd, notebookShell: INotebookShell, translator: ITranslator ): void => { const onChange = async () => { const current = notebookShell.currentWidget; if (!(current instanceof NotebookPanel)) { return; } const notebook = current.content; await current.context.ready; const widget = TrustedComponent.create({ notebook, translator }); notebookShell.add(widget, 'menu', { rank: 11_000, }); }; notebookShell.currentChanged.connect(onChange); }, }; /** * Export the plugins as default. */ const plugins: JupyterFrontEndPlugin[] = [ checkpoints, closeTab, kernelLogo, kernelStatus, scrollOutput, notebookToolsWidget, trusted, ]; export default plugins;