Interrupt kernel button on interactive window toolbar should be disabled when kernel is not busy

news/2 Fixes/7269.md

@@ -0,0 +1 @@
+Interrupt kernel button on interactive window toolbar should be disabled when kernel is not busy.

package.json

@@ -548,7 +548,7 @@
                     "light": "resources/light/interrupt.svg",
                     "dark": "resources/dark/interrupt.svg"
                 },
-                "enablement": "isWorkspaceTrusted"
+                "enablement": "isWorkspaceTrusted && jupyter.interactive.canInterruptNotebookKernel"
             },
             {
                 "command": "jupyter.restartkernel",
@@ -559,7 +559,7 @@
                     "light": "resources/light/restart-kernel.svg",
                     "dark": "resources/dark/restart-kernel.svg"
                 },
-                "enablement": "isWorkspaceTrusted"
+                "enablement": "isWorkspaceTrusted && jupyter.interactive.canRestartNotebookKernel"
             },
             {
                 "command": "jupyter.notebookeditor.interruptkernel",

src/client/datascience/commands/activeEditorContext.ts

@@ -14,7 +14,9 @@ import { traceError } from '../../common/logger';
 import { IDisposable, IDisposableRegistry } from '../../common/types';
 import { isNotebookCell } from '../../common/utils/misc';
 import { EditorContexts } from '../constants';
-import { getNotebookMetadata, isJupyterNotebook, isPythonNotebook } from '../notebook/helpers/helpers';
+import { getActiveInteractiveWindow } from '../interactive-window/helpers';
+import { JupyterNotebookView } from '../notebook/constants';
+import { getNotebookMetadata, isPythonNotebook } from '../notebook/helpers/helpers';
 import { IInteractiveWindow, IInteractiveWindowProvider, INotebook, INotebookProvider } from '../types';
 
 @injectable()
@@ -28,6 +30,8 @@ export class ActiveEditorContextService implements IExtensionSingleActivationSer
     private pythonOrInteractiveOrNativeContext: ContextKey;
     private canRestartNotebookKernelContext: ContextKey;
     private canInterruptNotebookKernelContext: ContextKey;
+    private canRestartInteractiveWindowKernelContext: ContextKey;
+    private canInterruptInteractiveWindowKernelContext: ContextKey;
     private hasNativeNotebookCells: ContextKey;
     private isPythonFileActive: boolean = false;
     private isPythonNotebook: ContextKey;
@@ -50,6 +54,14 @@ export class ActiveEditorContextService implements IExtensionSingleActivationSer
             EditorContexts.CanInterruptNotebookKernel,
             this.commandManager
         );
+        this.canRestartInteractiveWindowKernelContext = new ContextKey(
+            EditorContexts.CanRestartInteractiveWindowKernel,
+            this.commandManager
+        );
+        this.canInterruptInteractiveWindowKernelContext = new ContextKey(
+            EditorContexts.CanInterruptInteractiveWindowKernel,
+            this.commandManager
+        );
         this.interactiveContext = new ContextKey(EditorContexts.IsInteractiveActive, this.commandManager);
         this.interactiveOrNativeContext = new ContextKey(
             EditorContexts.IsInteractiveOrNativeActive,
@@ -82,6 +94,9 @@ export class ActiveEditorContextService implements IExtensionSingleActivationSer
         if (this.vscNotebook.activeNotebookEditor) {
             this.onDidChangeActiveNotebookEditor(this.vscNotebook.activeNotebookEditor);
         }
+        if (this.interactiveProvider.activeWindow) {
+            this.onDidChangeActiveInteractiveWindow();
+        }
         this.vscNotebook.onDidChangeActiveNotebookEditor(this.onDidChangeActiveNotebookEditor, this, this.disposables);
 
         // Do we already have python file opened.
@@ -100,24 +115,28 @@ export class ActiveEditorContextService implements IExtensionSingleActivationSer
     private onDidChangeActiveInteractiveWindow(e?: IInteractiveWindow) {
         this.interactiveContext.set(!!e).ignoreErrors();
         this.updateMergedContexts();
+        this.updateContextOfActiveInteractiveWindowKernel();
     }
     private onDidChangeActiveNotebookEditor(e?: NotebookEditor) {
-        const isJupyterNotebookDoc = e ? isJupyterNotebook(e.document) : false;
+        const isJupyterNotebookDoc = e ? e.document.notebookType === JupyterNotebookView : false;
         this.nativeContext.set(isJupyterNotebookDoc).ignoreErrors();
 
         this.isPythonNotebook
             .set(e && isJupyterNotebookDoc ? isPythonNotebook(getNotebookMetadata(e.document)) : false)
             .ignoreErrors();
         this.updateContextOfActiveNotebookKernel(e);
+        this.updateContextOfActiveInteractiveWindowKernel();
         this.updateNativeNotebookContext();
         this.updateNativeNotebookCellContext();
         this.updateMergedContexts();
     }
     private updateNativeNotebookContext() {
-        this.hasNativeNotebookOpen.set(this.vscNotebook.notebookDocuments.some(isJupyterNotebook)).ignoreErrors();
+        this.hasNativeNotebookOpen
+            .set(this.vscNotebook.notebookDocuments.some((nb) => nb.notebookType === JupyterNotebookView))
+            .ignoreErrors();
     }
     private updateContextOfActiveNotebookKernel(activeEditor?: NotebookEditor) {
-        if (activeEditor && isJupyterNotebook(activeEditor.document)) {
+        if (activeEditor && activeEditor.document.notebookType === JupyterNotebookView) {
             this.notebookProvider
                 .getOrCreateNotebook({
                     identity: activeEditor.document.uri,
@@ -140,23 +159,55 @@ export class ActiveEditorContextService implements IExtensionSingleActivationSer
             this.canInterruptNotebookKernelContext.set(false).ignoreErrors();
         }
     }
+    private updateContextOfActiveInteractiveWindowKernel() {
+        const interactiveWindow = getActiveInteractiveWindow(this.interactiveProvider);
+        if (interactiveWindow?.notebookUri) {
+            this.notebookProvider
+                .getOrCreateNotebook({
+                    identity: interactiveWindow.notebookUri,
+                    resource: interactiveWindow.owner,
+                    getOnly: true
+                })
+                .then(async (nb) => {
+                    if (
+                        getActiveInteractiveWindow(this.interactiveProvider) === interactiveWindow &&
+                        nb !== undefined
+                    ) {
+                        const canStart = nb && nb.status !== ServerStatus.NotStarted;
+                        this.canRestartInteractiveWindowKernelContext.set(!!canStart).ignoreErrors();
+                        const canInterrupt = nb && nb.status === ServerStatus.Busy;
+                        this.canInterruptInteractiveWindowKernelContext.set(!!canInterrupt).ignoreErrors();
+                    }
+                })
+                .catch(
+                    traceError.bind(
+                        undefined,
+                        'Failed to determine if a kernel is active for the current interactive window'
+                    )
+                );
+        } else {
+            this.canRestartInteractiveWindowKernelContext.set(false).ignoreErrors();
+            this.canInterruptInteractiveWindowKernelContext.set(false).ignoreErrors();
+        }
+    }
     private onDidKernelStatusChange({ notebook }: { status: ServerStatus; notebook: INotebook }) {
         // Ok, kernel status has changed.
         const activeEditor = this.vscNotebook.activeNotebookEditor;
-        if (!activeEditor) {
-            return;
-        }
-        if (activeEditor.document.uri.toString() !== notebook.identity.toString()) {
-            // Status of a notebook thats not related to active editor has changed.
-            // We can ignore that.
-            return;
+        const activeInteractiveWindow = getActiveInteractiveWindow(this.interactiveProvider);
+        if (
+            activeInteractiveWindow &&
+            activeInteractiveWindow.notebookUri?.toString() === notebook.identity.toString()
+        ) {
+            this.updateContextOfActiveInteractiveWindowKernel();
+        } else if (activeEditor && activeEditor.document.uri.toString() === notebook.identity.toString()) {
+            this.updateContextOfActiveNotebookKernel(activeEditor);
         }
-        this.updateContextOfActiveNotebookKernel(activeEditor);
     }
     private onDidChangeActiveTextEditor(e?: TextEditor) {
         this.isPythonFileActive = e?.document.languageId === PYTHON_LANGUAGE && !isNotebookCell(e.document.uri);
         this.updateNativeNotebookCellContext();
         this.updateMergedContexts();
+        this.updateContextOfActiveInteractiveWindowKernel();
     }
     private updateMergedContexts() {
         this.interactiveOrNativeContext

src/client/datascience/constants.ts

@@ -192,6 +192,8 @@ export namespace EditorContexts {
     export const HaveCellSelected = 'jupyter.havecellselected';
     export const CanRestartNotebookKernel = 'jupyter.notebookeditor.canrestartNotebookkernel';
     export const CanInterruptNotebookKernel = 'jupyter.notebookeditor.canInterruptNotebookKernel';
+    export const CanRestartInteractiveWindowKernel = 'jupyter.interactive.canRestartNotebookKernel';
+    export const CanInterruptInteractiveWindowKernel = 'jupyter.interactive.canInterruptNotebookKernel';
     export const DebuggingInProgress = 'jupyter.notebookeditor.debuggingInProgress';
     export const RunByLineInProgress = 'jupyter.notebookeditor.runByLineInProgress';
     export const IsPythonNotebook = 'jupyter.ispythonnotebook';

src/client/datascience/interactive-window/helpers.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { IInteractiveWindow, IInteractiveWindowProvider } from '../types';
+import { window } from 'vscode';
+import { NotebookCellScheme } from '../../common/constants';
+
+export function getActiveInteractiveWindow(
+    interactiveWindowProvider: IInteractiveWindowProvider
+): IInteractiveWindow | undefined {
+    if (interactiveWindowProvider.activeWindow) {
+        return interactiveWindowProvider.activeWindow;
+    }
+    if (window.activeTextEditor === undefined) {
+        return;
+    }
+    const textDocumentUri = window.activeTextEditor.document.uri;
+    if (textDocumentUri.scheme !== NotebookCellScheme) {
+        return interactiveWindowProvider.get(textDocumentUri);
+    }
+}

src/client/datascience/variablesView/notebookWatcher.ts

@@ -9,22 +9,16 @@ import {
     NotebookCellExecutionState,
     NotebookCellExecutionStateChangeEvent,
     Uri,
-    window,
     workspace
 } from 'vscode';
 import '../../common/extensions';
 import { IFileSystem } from '../../common/platform/types';
 import { IDisposableRegistry } from '../../common/types';
+import { getActiveInteractiveWindow } from '../interactive-window/helpers';
 import { IKernelProvider } from '../jupyter/kernels/types';
 import { isJupyterNotebook } from '../notebook/helpers/helpers';
 import { KernelState, KernelStateEventArgs } from '../notebookExtensibility';
-import {
-    IInteractiveWindow,
-    IInteractiveWindowProvider,
-    INotebook,
-    INotebookEditor,
-    INotebookEditorProvider
-} from '../types';
+import { IInteractiveWindowProvider, INotebook, INotebookEditor, INotebookEditorProvider } from '../types';
 import { IActiveNotebookChangedEvent, INotebookWatcher } from './types';
 
 interface IExecutionCountEntry {
@@ -49,7 +43,7 @@ export class NotebookWatcher implements INotebookWatcher {
         return this.notebookEditorProvider.activeEditor?.notebook || this.getActiveInteractiveWindowNotebook();
     }
     public get activeNotebookExecutionCount(): number | undefined {
-        const activeInteractiveWindow = this.getActiveInteractiveWindow();
+        const activeInteractiveWindow = getActiveInteractiveWindow(this.interactiveWindowProvider);
         const activeNotebookOrInteractiveWindow =
             this.notebookEditorProvider.activeEditor?.file || activeInteractiveWindow?.notebookUri;
         if (activeNotebookOrInteractiveWindow) {
@@ -187,7 +181,7 @@ export class NotebookWatcher implements INotebookWatcher {
         ) {
             return true;
         }
-        const activeInteractiveWindow = this.getActiveInteractiveWindow();
+        const activeInteractiveWindow = getActiveInteractiveWindow(this.interactiveWindowProvider);
         if (
             activeInteractiveWindow?.notebookUri !== undefined &&
             this.fileSystem.arePathsSame(activeInteractiveWindow.notebookUri, kernelStateEvent.resource)
@@ -197,16 +191,8 @@ export class NotebookWatcher implements INotebookWatcher {
         return false;
     }
 
-    private getActiveInteractiveWindow(): IInteractiveWindow | undefined {
-        if (window.activeTextEditor === undefined) {
-            return;
-        }
-        const textDocumentUri = window.activeTextEditor.document.uri;
-        return this.interactiveWindowProvider.get(textDocumentUri);
-    }
-
     private getActiveInteractiveWindowNotebook(): INotebook | undefined {
-        const interactiveWindow = this.getActiveInteractiveWindow();
+        const interactiveWindow = getActiveInteractiveWindow(this.interactiveWindowProvider);
         const notebookDocument = workspace.notebookDocuments.find(
             (notebookDocument) => notebookDocument.uri.toString() === interactiveWindow?.notebookUri?.toString()
         );