import { nbformat } from '@jupyterlab/coreutils'; import type { KernelMessage } from '@jupyterlab/services';+import { Subscription } from 'rxjs'; import { Observable } from 'rxjs/Observable'; import { Subject } from 'rxjs/Subject';-import { CancellationToken, Event, EventEmitter, Uri } from 'vscode';+import {+    CancellationToken,+    CancellationTokenSource,+    Event,+    EventEmitter,+    NotebookCell,+    NotebookCellRunState,+    NotebookDocument,+    Uri+} from 'vscode'; import { ServerStatus } from '../../../../datascience-ui/interactive-common/mainState';+import { ICommandManager } from '../../../common/application/types';+import { wrapCancellationTokens } from '../../../common/cancellation'; import { traceError } from '../../../common/logger'; import { IDisposableRegistry } from '../../../common/types'; import { createDeferred, Deferred } from '../../../common/utils/async';+import { noop } from '../../../common/utils/misc';+import { StopWatch } from '../../../common/utils/stopWatch';+import { IInterpreterService } from '../../../interpreter/contracts';+import { captureTelemetry, sendTelemetryEvent } from '../../../telemetry';+import { Commands, Telemetry, VSCodeNativeTelemetry } from '../../constants';+import {+    handleUpdateDisplayDataMessage,+    hasTransientOutputForAnotherCell,+    updateCellExecutionCount,+    updateCellOutput,+    updateCellWithErrorStatus+} from '../../notebook/helpers/executionHelpers';+import {+    clearCellForExecution,+    getCellStatusMessageBasedOnFirstCellErrorOutput,+    updateCellExecutionTimes+} from '../../notebook/helpers/helpers';+import { MultiCancellationTokenSource } from '../../notebook/helpers/multiCancellationToken';+import { NotebookEditor } from '../../notebook/notebookEditor';+import { INotebookContentProvider } from '../../notebook/types'; import { getDefaultNotebookContent, updateNotebookMetadata } from '../../notebookStorage/baseModel';-import type {+import {     ICell,+    IDataScienceErrorHandler,     IJupyterKernelSpec,     INotebook,+    INotebookEditorProvider,     INotebookProvider,     INotebookProviderConnection,     InterruptResult,     KernelSocketInformation } from '../../types';-import type { IKernel, KernelSelection, LiveKernelModel } from './types';+import { KernelProvider } from './kernelProvider';+import type { IKernel, IKernelSelectionUsage, KernelSelection, LiveKernelModel } from './types';+// tslint:disable-next-line: no-var-requires no-require-imports+const vscodeNotebookEnums = require('vscode') as typeof import('vscode-proposed');++/**+ * Separate class that deals just with kernel execution.+ * Else the `Kernel` class gets very big.+ */+class KernelExecution {+    public notebook?: INotebook;+    private readonly registeredIOPubListeners = new WeakSet<IKernel>();+    private readonly cellExecutions = new WeakMap<NotebookCell, MultiCancellationTokenSource>();+    private readonly documentExecutions = new WeakMap<NotebookDocument, MultiCancellationTokenSource>();+    private readonly pendingExecutionCancellations = new Map<string, CancellationTokenSource[]>();+    private readonly documentsWithPendingCellExecutions = new WeakMap<NotebookDocument, NotebookCell | undefined>();+    private readonly tokensInterrupted = new WeakSet<CancellationToken>();+    private sentExecuteCellTelemetry: boolean = false;+    private readonly cellsQueueForExecutionButNotYetExecuting = new WeakSet<NotebookCell>();+    private readonly kernelValidated = new WeakMap<NotebookDocument, { kernel: IKernel; promise: Promise<void> }>();+    constructor(+        private readonly kernelProvider: KernelProvider,+        private readonly commandManager: ICommandManager,+        private readonly interpreterService: IInterpreterService,+        private readonly errorHandler: IDataScienceErrorHandler,+        private readonly contentProvider: INotebookContentProvider,+        private readonly editorProvider: INotebookEditorProvider,+        readonly kernelSelectionUsage: IKernelSelectionUsage+    ) {}+    @captureTelemetry(Telemetry.ExecuteNativeCell, undefined, true)+    public async executeCell(cell: NotebookCell): Promise<void> {+        if (!this.notebook) {+            throw new Error('executeObservable cannot be called if kernel has not been started!');+        }+        if (this.cellExecutions.has(cell)) {+            return;+        }+        const source = new MultiCancellationTokenSource();+        const token = source.token;+        this.cellExecutions.set(cell, source);++        // Cannot execute empty cells.+        if (cell.document.getText().trim().length === 0) {+            return;+        }+        const stopWatch = new StopWatch();+        const kernel = this.getKernel(cell.notebook);+        this.cellsQueueForExecutionButNotYetExecuting.add(cell);+        // Mark cells as busy (this way there's immediate feedback to users).+        // If it does not complete, then restore old state.+        const oldCellState = cell.metadata.runState;+        cell.metadata.runState = vscodeNotebookEnums.NotebookCellRunState.Running;++        // If we cancel running cells, then restore the state to previous values unless cell has completed.+        token.onCancellationRequested(() => {+            if (this.cellsQueueForExecutionButNotYetExecuting.has(cell)) {+                cell.metadata.runState = oldCellState;+            }+        });++        await this.executeIndividualCell(kernel, cell, token, stopWatch);+    }+    @captureTelemetry(Telemetry.ExecuteNativeCell, undefined, true)+    @captureTelemetry(VSCodeNativeTelemetry.RunAllCells, undefined, true)+    public async executeAllCells(document: NotebookDocument): Promise<void> {+        if (!this.notebook) {+            throw new Error('executeObservable cannot be called if kernel has not been started!');+        }+        if (this.documentExecutions.has(document)) {+            return;+        }+        const source = new MultiCancellationTokenSource();+        const token = source.token;+        this.documentExecutions.set(document, source);+        const stopWatch = new StopWatch();+        const kernel = this.getKernel(document);+        document.metadata.runState = vscodeNotebookEnums.NotebookRunState.Running;+        // Mark all cells as busy (this way there's immediate feedback to users).+        // If it does not complete, then restore old state.+        const oldCellStates = new WeakMap<NotebookCell, NotebookCellRunState | undefined>();+        document.cells.forEach((cell) => {+            if (+                cell.document.getText().trim().length === 0 ||+                cell.cellKind === vscodeNotebookEnums.CellKind.Markdown+            ) {+                return;+            }+            this.cellsQueueForExecutionButNotYetExecuting.add(cell);+            oldCellStates.set(cell, cell.metadata.runState);+            cell.metadata.runState = vscodeNotebookEnums.NotebookCellRunState.Running;+        });++        const restoreOldCellState = (cell: NotebookCell) => {+            if (oldCellStates.has(cell) && this.cellsQueueForExecutionButNotYetExecuting.has(cell)) {+                cell.metadata.runState = oldCellStates.get(cell);+            }+        };+        // If we cancel running cells, then restore the state to previous values unless cell has completed.+        token.onCancellationRequested(() => {+            if (!this.documentsWithPendingCellExecutions.has(document)) {+                document.metadata.runState = vscodeNotebookEnums.NotebookRunState.Idle;+            }+            document.cells.forEach(restoreOldCellState);+        });++        let executingAPreviousCellHasFailed = false;+        await document.cells.reduce((previousPromise, cellToExecute) => {+            return previousPromise.then((previousCellState) => {+                // If a previous cell has failed or execution cancelled, the get out.+                if (+                    executingAPreviousCellHasFailed ||+                    token.isCancellationRequested ||+                    previousCellState === vscodeNotebookEnums.NotebookCellRunState.Error+                ) {+                    executingAPreviousCellHasFailed = true;+                    restoreOldCellState(cellToExecute);+                    return;+                }+                if (+                    cellToExecute.document.getText().trim().length === 0 ||+                    cellToExecute.cellKind === vscodeNotebookEnums.CellKind.Markdown+                ) {+                    return;+                }+                return this.executeIndividualCell(kernel, cellToExecute, token, stopWatch);+            });+        }, Promise.resolve<NotebookCellRunState | undefined>(undefined));++        document.metadata.runState = vscodeNotebookEnums.NotebookRunState.Idle;+    }+    public cancelCell(cell: NotebookCell) {+        this.cellExecutions.get(cell)?.cancel(); // NOSONAR+    }+    public cancelAllCells(document: NotebookDocument) {+        this.documentExecutions.get(document)?.cancel(); // NOSONAR+        document.cells.forEach((cell) => this.cancelCell(cell));+    }+    public cancelPendingExecutions(document: NotebookDocument): void {+        this.pendingExecutionCancellations.get(document.uri.fsPath)?.forEach((cancellation) => cancellation.cancel()); // NOSONAR+    }+    private async getKernel(document: NotebookDocument): Promise<IKernel> {+        await this.validate(document);+        let kernel = this.kernelProvider.get(document.uri);+        if (!kernel) {+            const activeInterpreter = await this.interpreterService.getActiveInterpreter(document.uri);+            kernel = this.kernelProvider.getOrCreate(document.uri, {+                metadata: { interpreter: activeInterpreter!, kernelModel: undefined, kernelSpec: undefined },+                launchingFile: document.uri.fsPath+            });+        }+        if (!kernel) {+            throw new Error('Unable to create a Kernel to run cell');+        }+        await kernel.start();+        return kernel;+    }+    private sendPerceivedCellExecute(runningStopWatch: StopWatch) {+        const props = { notebook: true };+        if (!this.sentExecuteCellTelemetry) {+            this.sentExecuteCellTelemetry = true;+            sendTelemetryEvent(Telemetry.ExecuteCellPerceivedCold, runningStopWatch.elapsedTime, props);+        } else {+            sendTelemetryEvent(Telemetry.ExecuteCellPerceivedWarm, runningStopWatch.elapsedTime, props);+        }+    }++    private async executeIndividualCell(+        kernelPromise: Promise<IKernel>,+        cell: NotebookCell,+        token: CancellationToken,+        stopWatch: StopWatch+    ): Promise<NotebookCellRunState | undefined> {+        if (!this.notebook) {+            throw new Error('No notebook object');+        }+        if (token.isCancellationRequested) {+            return;+        }+        const kernel = await kernelPromise;+        if (token.isCancellationRequested) {+            return;+        }+        const document = cell.notebook;+        const editor = this.editorProvider.editors.find((e) => e.file.toString() === document.uri.toString());+        if (!editor) {+            throw new Error('No editor for Model');+        }+        if (editor && !(editor instanceof NotebookEditor)) {+            throw new Error('Executing Notebook with another Editor');+        }+        // If we need to cancel this execution (from our code, due to kernel restarts or similar, then cancel).+        const cancelExecution = new CancellationTokenSource();+        if (!this.pendingExecutionCancellations.has(document.uri.fsPath)) {+            this.pendingExecutionCancellations.set(document.uri.fsPath, []);+        }+        // If kernel is restarted while executing, then abort execution.+        const cancelExecutionCancellation = new CancellationTokenSource();+        this.pendingExecutionCancellations.get(document.uri.fsPath)?.push(cancelExecutionCancellation); // NOSONAR++        // Replace token with a wrapped cancellation, which will wrap cancellation due to restarts.+        const wrappedToken = wrapCancellationTokens(token, cancelExecutionCancellation.token, cancelExecution.token);+        const kernelDisposedDisposable = kernel.onDisposed(() => {+            cancelExecutionCancellation.cancel();+        });++        // tslint:disable-next-line: no-suspicious-comment+        // TODO: How can nb be null?+        // We should throw an exception or change return type to be non-nullable.+        // Else in places where it shouldn't be null we'd end up treating it as null (i.e. ignoring error conditions, like this).++        this.handleDisplayDataMessages(document, kernel);++        const deferred = createDeferred<NotebookCellRunState>();+        wrappedToken.onCancellationRequested(() => {+            if (deferred.completed) {+                return;+            }++            // Interrupt kernel only if original cancellation was cancelled.+            // I.e. interrupt kernel only if user attempts to stop the execution by clicking stop button.+            if (token.isCancellationRequested && !this.tokensInterrupted.has(token)) {+                this.tokensInterrupted.add(token);+                this.commandManager.executeCommand(Commands.NotebookEditorInterruptKernel).then(noop, noop);+            }+        });++        // Ensure we clear the cell state and trigger a change.+        clearCellForExecution(cell);+        const executionStopWatch = new StopWatch();+        cell.metadata.runStartTime = new Date().getTime();+        this.contentProvider.notifyChangesToDocument(document);+        this.cellsQueueForExecutionButNotYetExecuting.delete(cell);+        this.documentsWithPendingCellExecutions.set(document, cell);+        let subscription: Subscription | undefined;+        try {+            editor.notifyExecution(cell.document.getText());+            this.notebook.clear(cell.uri.toString());+            const observable = this.notebook.executeObservable(+                cell.document.getText(),+                document.fileName,+                0,+                cell.uri.toString(),+                false+            );+            subscription = observable?.subscribe(+                (cells) => {+                    const rawCellOutput = cells+                        .filter((item) => item.id === cell.uri.toString())+                        .flatMap((item) => (item.data.outputs as unknown) as nbformat.IOutput[])+                        .filter((output) => !hasTransientOutputForAnotherCell(output));++                    // Set execution count, all messages should have it+                    if (+                        cells.length &&+                        'execution_count' in cells[0].data &&+                        typeof cells[0].data.execution_count === 'number'+                    ) {+                        const executionCount = cells[0].data.execution_count as number;+                        if (updateCellExecutionCount(cell, executionCount)) {+                            this.contentProvider.notifyChangesToDocument(document);+                        }+                    }++                    if (updateCellOutput(cell, rawCellOutput)) {+                        this.contentProvider.notifyChangesToDocument(document);+                    }+                },+                (error: Partial<Error>) => {+                    updateCellWithErrorStatus(cell, error);+                    this.contentProvider.notifyChangesToDocument(document);+                    this.errorHandler.handleError((error as unknown) as Error).ignoreErrors();+                    deferred.resolve(cell.metadata.runState);+                },+                () => {+                    cell.metadata.lastRunDuration = executionStopWatch.elapsedTime;+                    cell.metadata.runState = wrappedToken.isCancellationRequested+                        ? vscodeNotebookEnums.NotebookCellRunState.Idle+                        : vscodeNotebookEnums.NotebookCellRunState.Success;+                    cell.metadata.statusMessage = '';+                    updateCellExecutionTimes(cell, {+                        startTime: cell.metadata.runStartTime,+                        duration: cell.metadata.lastRunDuration+                    });++                    // If there are any errors in the cell, then change status to error.+                    if (cell.outputs.some((output) => output.outputKind === vscodeNotebookEnums.CellOutputKind.Error)) {+                        cell.metadata.runState = vscodeNotebookEnums.NotebookCellRunState.Error;+                        cell.metadata.statusMessage = getCellStatusMessageBasedOnFirstCellErrorOutput(cell.outputs);+                    }++                    this.contentProvider.notifyChangesToDocument(document);+                    deferred.resolve(cell.metadata.runState);+                }+            );

  import { nbformat } from '@jupyterlab/coreutils'; import type { KernelMessage } from '@jupyterlab/services';+import { Subscription } from 'rxjs'; import { Observable } from 'rxjs/Observable'; import { Subject } from 'rxjs/Subject';-import { CancellationToken, Event, EventEmitter, Uri } from 'vscode';+import {+    CancellationToken,+    CancellationTokenSource,+    Event,+    EventEmitter,+    NotebookCell,+    NotebookCellRunState,+    NotebookDocument,+    Uri+} from 'vscode'; import { ServerStatus } from '../../../../datascience-ui/interactive-common/mainState';+import { ICommandManager } from '../../../common/application/types';+import { wrapCancellationTokens } from '../../../common/cancellation'; import { traceError } from '../../../common/logger'; import { IDisposableRegistry } from '../../../common/types'; import { createDeferred, Deferred } from '../../../common/utils/async';+import { noop } from '../../../common/utils/misc';+import { StopWatch } from '../../../common/utils/stopWatch';+import { IInterpreterService } from '../../../interpreter/contracts';+import { captureTelemetry, sendTelemetryEvent } from '../../../telemetry';+import { Commands, Telemetry, VSCodeNativeTelemetry } from '../../constants';+import {+    handleUpdateDisplayDataMessage,+    hasTransientOutputForAnotherCell,+    updateCellExecutionCount,+    updateCellOutput,+    updateCellWithErrorStatus+} from '../../notebook/helpers/executionHelpers';+import {+    clearCellForExecution,+    getCellStatusMessageBasedOnFirstCellErrorOutput,+    updateCellExecutionTimes+} from '../../notebook/helpers/helpers';+import { MultiCancellationTokenSource } from '../../notebook/helpers/multiCancellationToken';+import { NotebookEditor } from '../../notebook/notebookEditor';+import { INotebookContentProvider } from '../../notebook/types'; import { getDefaultNotebookContent, updateNotebookMetadata } from '../../notebookStorage/baseModel';-import type {+import {     ICell,+    IDataScienceErrorHandler,     IJupyterKernelSpec,     INotebook,+    INotebookEditorProvider,     INotebookProvider,     INotebookProviderConnection,     InterruptResult,     KernelSocketInformation } from '../../types';-import type { IKernel, KernelSelection, LiveKernelModel } from './types';+import { KernelProvider } from './kernelProvider';+import type { IKernel, IKernelSelectionUsage, KernelSelection, LiveKernelModel } from './types';+// tslint:disable-next-line: no-var-requires no-require-imports+const vscodeNotebookEnums = require('vscode') as typeof import('vscode-proposed');++/**+ * Separate class that deals just with kernel execution.+ * Else the `Kernel` class gets very big.+ */+class KernelExecution {+    public notebook?: INotebook;+    private readonly registeredIOPubListeners = new WeakSet<IKernel>();+    private readonly cellExecutions = new WeakMap<NotebookCell, MultiCancellationTokenSource>();

 export interface IKernel extends IAsyncDisposable {     readonly disposed: boolean;     readonly kernelSocket: Observable<KernelSocketInformation | undefined>;     start(): Promise<void>;-    interrupt(timeoutInMs: number): Promise<InterruptResult>;-    restart(timeoutInMs: number): Promise<void>;-    executeObservable(code: string, file: string, line: number, id: string, silent: boolean): Observable<ICell[]>;+    interrupt(): Promise<InterruptResult>;+    restart(): Promise<void>;+    executeCell(cell: NotebookCell): Promise<void>;+    executeAllCells(document: NotebookDocument): Promise<void>;

  import { nbformat } from '@jupyterlab/coreutils'; import type { KernelMessage } from '@jupyterlab/services';+import { Subscription } from 'rxjs'; import { Observable } from 'rxjs/Observable'; import { Subject } from 'rxjs/Subject';-import { CancellationToken, Event, EventEmitter, Uri } from 'vscode';+import {+    CancellationToken,+    CancellationTokenSource,+    Event,+    EventEmitter,+    NotebookCell,+    NotebookCellRunState,+    NotebookDocument,+    Uri+} from 'vscode'; import { ServerStatus } from '../../../../datascience-ui/interactive-common/mainState';+import { ICommandManager } from '../../../common/application/types';+import { wrapCancellationTokens } from '../../../common/cancellation'; import { traceError } from '../../../common/logger'; import { IDisposableRegistry } from '../../../common/types'; import { createDeferred, Deferred } from '../../../common/utils/async';+import { noop } from '../../../common/utils/misc';+import { StopWatch } from '../../../common/utils/stopWatch';+import { IInterpreterService } from '../../../interpreter/contracts';+import { captureTelemetry, sendTelemetryEvent } from '../../../telemetry';+import { Commands, Telemetry, VSCodeNativeTelemetry } from '../../constants';+import {+    handleUpdateDisplayDataMessage,+    hasTransientOutputForAnotherCell,+    updateCellExecutionCount,+    updateCellOutput,+    updateCellWithErrorStatus+} from '../../notebook/helpers/executionHelpers';+import {+    clearCellForExecution,+    getCellStatusMessageBasedOnFirstCellErrorOutput,+    updateCellExecutionTimes+} from '../../notebook/helpers/helpers';+import { MultiCancellationTokenSource } from '../../notebook/helpers/multiCancellationToken';+import { NotebookEditor } from '../../notebook/notebookEditor';+import { INotebookContentProvider } from '../../notebook/types'; import { getDefaultNotebookContent, updateNotebookMetadata } from '../../notebookStorage/baseModel';-import type {+import {     ICell,+    IDataScienceErrorHandler,     IJupyterKernelSpec,     INotebook,+    INotebookEditorProvider,     INotebookProvider,     INotebookProviderConnection,     InterruptResult,     KernelSocketInformation } from '../../types';-import type { IKernel, KernelSelection, LiveKernelModel } from './types';+import { KernelProvider } from './kernelProvider';+import type { IKernel, IKernelSelectionUsage, KernelSelection, LiveKernelModel } from './types';+// tslint:disable-next-line: no-var-requires no-require-imports+const vscodeNotebookEnums = require('vscode') as typeof import('vscode-proposed');++/**+ * Separate class that deals just with kernel execution.+ * Else the `Kernel` class gets very big.+ */+class KernelExecution {

 import { KernelSelection } from '../jupyter/kernels/types'; import { INotebookStorageProvider } from '../notebookStorage/notebookStorageProvider'; import { INotebook, INotebookProvider } from '../types'; import { getNotebookMetadata, isJupyterNotebook, updateKernelInNotebookMetadata } from './helpers/helpers';-import { NotebookKernel } from './notebookKernel';-import { INotebookContentProvider, INotebookExecutionService } from './types';+import { INotebookContentProvider } from './types';++class VSCodeNotebookKernelMetadata implements VSCNotebookKernel {+    get preloads(): Uri[] {

 export class NotebookEditorProvider implements INotebookEditorProvider {     }     @captureTelemetry(Telemetry.CreateNewNotebook, undefined, false)     public async createNew(contents?: string): Promise<INotebookEditor> {+        const settings = this.configurationService.getSettings();+        if (settings.languageServer === LanguageServerType.Jedi) {

 export class NotebookEditorProvider implements INotebookEditorProvider {     }     @captureTelemetry(Telemetry.CreateNewNotebook, undefined, false)     public async createNew(contents?: string): Promise<INotebookEditor> {+        const settings = this.configurationService.getSettings();+        if (settings.languageServer === LanguageServerType.Jedi) {

  'use strict'; +import * as fastDeepEqual from 'fast-deep-equal';

 export interface IKernelSelectionUsage { export interface IKernel extends IAsyncDisposable {     readonly uri: Uri;     readonly kernelSpec?: IJupyterKernelSpec | LiveKernelModel;+    readonly metadata: Readonly<KernelSelection>;

 export class JupyterNotebookBase implements INotebook {      private generateRequest = (         code: string,-        silent?: boolean+        silent?: boolean,+        metadata?: JSONObject

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++'use strict';++import { inject, injectable } from 'inversify';+import { Uri } from 'vscode';+import { traceWarning } from '../../../common/logger';+import { IAsyncDisposableRegistry, IConfigurationService, IDisposableRegistry } from '../../../common/types';+import { INotebookProvider } from '../../types';+import { Kernel } from './kernel';+import { IKernel, KernelOptions } from './types';++@injectable()+export class KernelProvider {+    private readonly kernelsByUri = new Map<string, { options: KernelOptions; kernel: IKernel }>();+    constructor(+        @inject(IAsyncDisposableRegistry) private asyncDisposables: IAsyncDisposableRegistry,+        @inject(IDisposableRegistry) private disposables: IDisposableRegistry,+        @inject(INotebookProvider) private notebookProvider: INotebookProvider,+        @inject(IConfigurationService) private configService: IConfigurationService+    ) {}+    public get(uri: Uri): IKernel | undefined {+        return this.kernelsByUri.get(uri.toString())?.kernel;+    }+    public getOrCreate(uri: Uri, options: KernelOptions): IKernel | undefined {+        const existingKernelInfo = this.kernelsByUri.get(uri.toString());+        if (+            existingKernelInfo &&+            JSON.stringify(existingKernelInfo.options.metadata) === JSON.stringify(options.metadata)+        ) {+            return existingKernelInfo.kernel;+        }++        this.disposeOldKernel(uri);++        const waitForIdleTimeout =+            options?.waitForIdleTimeout ?? this.configService.getSettings(uri).datascience.jupyterLaunchTimeout;+        const kernel = new Kernel(+            uri,+            options.metadata,+            this.notebookProvider,+            this.disposables,+            waitForIdleTimeout,+            options.launchingFile+        );+        this.asyncDisposables.push(kernel);+        this.kernelsByUri.set(uri.toString(), { options, kernel });+        this.deleteMappingIfKernelIdDisposed(uri, kernel);

 suite('DataScience - VSCode Notebook - (Saving)', function () {             cell4 = vscodeNotebook.activeNotebookEditor?.document.cells![3]!;         }         initializeCells();-        await commands.executeCommand('notebook.execute');

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++'use strict';++import { nbformat } from '@jupyterlab/coreutils';+import type { KernelMessage } from '@jupyterlab/services';+import { Observable } from 'rxjs/Observable';+import { Subject } from 'rxjs/Subject';+import { CancellationToken, Event, EventEmitter, Uri } from 'vscode';+import { ServerStatus } from '../../../../datascience-ui/interactive-common/mainState';+import { traceError } from '../../../common/logger';+import { IDisposableRegistry } from '../../../common/types';+import { createDeferred, Deferred } from '../../../common/utils/async';+import { getDefaultNotebookContent, updateNotebookMetadata } from '../../notebookStorage/baseModel';+import type {+    ICell,+    IJupyterKernelSpec,+    INotebook,+    INotebookProvider,+    INotebookProviderConnection,+    KernelSocketInformation+} from '../../types';+import type { IKernel, KernelSelection, LiveKernelModel } from './types';++export class Kernel implements IKernel {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++'use strict';++import { nbformat } from '@jupyterlab/coreutils';+import type { KernelMessage } from '@jupyterlab/services';+import { Observable } from 'rxjs/Observable';+import { Subject } from 'rxjs/Subject';+import { CancellationToken, Event, EventEmitter, Uri } from 'vscode';+import { ServerStatus } from '../../../../datascience-ui/interactive-common/mainState';+import { traceError } from '../../../common/logger';+import { IDisposableRegistry } from '../../../common/types';+import { createDeferred, Deferred } from '../../../common/utils/async';+import { getDefaultNotebookContent, updateNotebookMetadata } from '../../notebookStorage/baseModel';+import type {+    ICell,+    IJupyterKernelSpec,+    INotebook,+    INotebookProvider,+    INotebookProviderConnection,+    KernelSocketInformation+} from '../../types';+import type { IKernel, KernelSelection, LiveKernelModel } from './types';++export class Kernel implements IKernel {+    get connection(): INotebookProviderConnection | undefined {+        return this._notebook?.connection;+    }+    get kernelSpec(): IJupyterKernelSpec | LiveKernelModel | undefined {+        if (this._notebook) {+            return this._notebook.getKernelSpec();+        }+        return this._metadata.kernelSpec || this._metadata.kernelModel;+    }+    get onStatusChanged(): Event<ServerStatus> {+        return this._onStatusChanged.event;+    }+    get onRestarted(): Event<void> {+        return this._onRestarted.event;+    }+    get onDisposed(): Event<void> {+        return this._onDisposed.event;+    }+    get status(): ServerStatus {+        return this._notebook?.status ?? ServerStatus.NotStarted;+    }+    get disposed(): boolean {+        return this._disposed === true || this._notebook?.disposed === true;+    }+    get kernelSocket(): Observable<KernelSocketInformation | undefined> {+        return this._kernelSocket.asObservable();+    }+    private _disposed?: boolean;+    private readonly _kernelSocket = new Subject<KernelSocketInformation | undefined>();+    private readonly _onStatusChanged = new EventEmitter<ServerStatus>();+    private readonly _onRestarted = new EventEmitter<void>();+    private readonly _onDisposed = new EventEmitter<void>();+    private _notebook?: INotebook;+    private _notebookPromise?: Promise<INotebook | undefined>;+    private readonly hookedNotebookForEvents = new WeakSet<INotebook>();+    private restarting?: Deferred<void>;+    // executeObservable(code: string, file: string, line: number, id: string, silent: boolean): Observable<ICell[]>;+    constructor(+        public readonly uri: Uri,+        private readonly _metadata: KernelSelection,

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++'use strict';++import { nbformat } from '@jupyterlab/coreutils';+import type { KernelMessage } from '@jupyterlab/services';+import { Observable } from 'rxjs/Observable';+import { Subject } from 'rxjs/Subject';+import { CancellationToken, Event, EventEmitter, Uri } from 'vscode';+import { ServerStatus } from '../../../../datascience-ui/interactive-common/mainState';+import { traceError } from '../../../common/logger';+import { IDisposableRegistry } from '../../../common/types';+import { createDeferred, Deferred } from '../../../common/utils/async';+import { getDefaultNotebookContent, updateNotebookMetadata } from '../../notebookStorage/baseModel';+import type {+    ICell,+    IJupyterKernelSpec,+    INotebook,+    INotebookProvider,+    INotebookProviderConnection,+    KernelSocketInformation+} from '../../types';+import type { IKernel, KernelSelection, LiveKernelModel } from './types';++export class Kernel implements IKernel {

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { inject, injectable } from 'inversify';+import { CancellationToken, Event, EventEmitter } from 'vscode';+import {+    NotebookCommunication,+    NotebookDocument,+    NotebookKernel as VSCNotebookKernel,+    NotebookKernelProvider+} from '../../../../types/vscode-proposed';+import { IVSCodeNotebook } from '../../common/application/types';+import { createPromiseFromCancellation } from '../../common/cancellation';+import { IDisposableRegistry } from '../../common/types';+import { noop } from '../../common/utils/misc';+import { KernelSelectionProvider } from '../jupyter/kernels/kernelSelections';+import { KernelSelector } from '../jupyter/kernels/kernelSelector';+import { KernelSwitcher } from '../jupyter/kernels/kernelSwitcher';+import { INotebook, INotebookProvider } from '../types';+import { updateKernelInNotebookMetadata } from './helpers/helpers';+import { NotebookKernel } from './notebookKernel';+import { INotebookContentProvider, INotebookExecutionService } from './types';+@injectable()+export class KernelProvider implements NotebookKernelProvider {+    public get onDidChangeKernels(): Event<void> {+        return this._onDidChangeKernels.event;+    }+    private readonly _onDidChangeKernels = new EventEmitter<void>();+    private notebookKernelChangeHandled = new WeakSet<INotebook>();+    constructor(+        @inject(INotebookExecutionService) private readonly execution: INotebookExecutionService,+        @inject(KernelSelectionProvider) private readonly kernelSelectionProvider: KernelSelectionProvider,+        @inject(KernelSelector) private readonly kernelSelector: KernelSelector,+        @inject(IVSCodeNotebook) private readonly notebook: IVSCodeNotebook,+        @inject(INotebookProvider) private readonly notebookProvider: INotebookProvider,+        @inject(KernelSwitcher) private readonly kernelSwitcher: KernelSwitcher,+        @inject(INotebookContentProvider) private readonly notebookContentProvider: INotebookContentProvider,+        @inject(IDisposableRegistry) private readonly disposables: IDisposableRegistry+    ) {+        this.kernelSelectionProvider.SelectionsChanged(() => this._onDidChangeKernels.fire(), this, disposables);+        this.notebook.onDidChangeActiveNotebookKernel(this.onDidChangeActiveNotebookKernel, this, disposables);+    }+    /**+     * Called before running code against a kernel. An initialization phase.+     * If the selected kernel is being validated, we can block here.+     */+    public async resolveKernel(+        kernel: NotebookKernel,+        document: NotebookDocument,+        _webview: NotebookCommunication,+        token: CancellationToken+    ): Promise<void> {+        return Promise.race([+            kernel.validate(document.uri).then(() => void 0),

     "downloading.file.progress": "{0}{1} of {2} KB ({3}%)",     "DataScience.jupyterDataRateExceeded": "Cannot view variable because data rate exceeded. Please restart your server with a higher data rate limit. For example, --NotebookApp.iopub_data_rate_limit=10000000000.0",     "DataScience.addCellBelowCommandTitle": "Add cell",-    "DataScience.debugCellCommandTitle": "Debug cell",+    "DataScience.debugCellCommandTitle": "Debug Cell",

                     "command": "python.datascience.insertCellBelowPosition",                     "title": "%python.command.python.datascience.insertCellBelowPosition.title%",                     "category": "Python",-                    "when": "python.datascience.hascodecells && editorFocus && editorLangId == python && python.datascience.featureenabled"+                    "when": "python.datascience.hascodecells && python.datascience.featureenabled && !notebookEditorFocused"