Update Jupyter Npm To Latest (#15897)

* Update JupyterLab pkgs, support WS Protocols

* Updates

* Remove debugger statements

* Revert disabling websocket protocol

* misc

* Fixes

* Fix tests

* More updates

* Update minimum version of renderer extension

* Updates to build

* Fixes

Author: DonJayamanne

build/ci/postInstall.js

@@ -9,35 +9,7 @@ const path = require('path');
 const constants = require('../constants');
 const common = require('../webpack/common');
 const { downloadZMQ } = require('@vscode/zeromq');
-/**
- * In order to get raw kernels working, we reuse the default kernel that jupyterlab ships.
- * However it expects to be talking to a websocket which is serializing the messages to strings.
- * Our raw kernel is not a web socket and needs to do its own serialization. To do so, we make a copy
- * of the default kernel with the serialization stripped out. This is simpler than making a copy of the module
- * at runtime.
- */
-function createJupyterKernelWithoutSerialization() {
-    var relativePath = path.join('node_modules', '@jupyterlab', 'services', 'lib', 'kernel', 'default.js');
-    var filePath = path.join(constants.ExtensionRootDir, relativePath);
-    if (!fs.existsSync(filePath)) {
-        throw new Error(
-            "Jupyter lab default kernel not found '" + filePath + "' (Jupyter Extension post install script)"
-        );
-    }
-    var fileContents = fs.readFileSync(filePath, { encoding: 'utf8' });
-    var replacedContents = fileContents
-        .replace(/^const serialize =.*$/gm, 'const serialize = { serialize: (a) => a, deserialize: (a) => a };')
-        .replace(
-            'const owned = team.session === this.clientId;',
-            'const owned = parentHeader.session === this.clientId;'
-        );
-    if (replacedContents === fileContents) {
-        throw new Error('Jupyter lab default kernel cannot be made non serializing');
-    }
-    var destPath = path.join(path.dirname(filePath), 'nonSerializingKernel.js');
-    fs.writeFileSync(destPath, replacedContents);
-    console.log(colors.green(destPath + ' file generated (by Jupyter VSC)'));
-}
+
 function fixVariableNameInKernelDefaultJs() {
     var relativePath = path.join('node_modules', '@jupyterlab', 'services', 'lib', 'kernel', 'default.js');
     var filePath = path.join(constants.ExtensionRootDir, relativePath);
@@ -228,7 +200,6 @@ function commentOutInvalidExport() {
 
 fixJupyterLabRenderers();
 makeVariableExplorerAlwaysSorted();
-createJupyterKernelWithoutSerialization();
 fixVariableNameInKernelDefaultJs();
 removeUnnecessaryLoggingFromKernelDefault();
 fixStripComments();

build/esbuild/build.ts

@@ -34,7 +34,7 @@ const deskTopNodeModulesToExternalize = [
     '@jupyterlab/services',
     '@jupyterlab/nbformat',
     '@jupyterlab/services/lib/kernel/serialize',
-    '@jupyterlab/services/lib/kernel/nonSerializingKernel',
+    '@jupyterlab/services/lib/kernel/default',
     'vscode-jsonrpc' // Used by a few modules, might as well pull this out, instead of duplicating it in separate bundles.
 ];
 const commonExternals = [

package-lock.json

@@ -2128,13 +2128,13 @@
     "dependencies": {
         "@c4312/evt": "^0.1.1",
         "@enonic/fnv-plus": "^1.3.0",
-        "@jupyter-widgets/base": "4.0.0",
-        "@jupyter-widgets/controls": "3.0.0",
-        "@jupyter-widgets/schema": "0.4.0",
-        "@jupyterlab/coreutils": "5.1.17",
-        "@jupyterlab/nbformat": "3.1.17",
-        "@jupyterlab/services": "6.1.17",
-        "@lumino/widgets": "^1.28.0",
+        "@jupyter-widgets/base": "^6.0.8",
+        "@jupyter-widgets/controls": "^5.0.9",
+        "@jupyter-widgets/schema": "^0.5.5",
+        "@jupyterlab/coreutils": "^6.2.4",
+        "@jupyterlab/nbformat": "^4.2.4",
+        "@jupyterlab/services": "^7.2.4",
+        "@lumino/widgets": "^2.4.0",
         "@nteract/messaging": "^7.0.0",
         "@vscode/extension-telemetry": "^0.7.7",
         "@vscode/python-extension": "^1.0.4",

package.json

@@ -58,6 +58,11 @@ export abstract class BaseJupyterSessionConnection<
      * The kernel anyMessage signal, proxied from the current kernel.
      */
     anyMessage = new Signal<this, Kernel.IAnyMessageArgs>(this);
+    /**
+     * The kernel pendingInput signal, proxied from the current
+     * kernel.
+     */
+    pendingInput = new Signal<this, boolean>(this);
 
     constructor(
         public readonly kind: T,
@@ -70,6 +75,7 @@ export abstract class BaseJupyterSessionConnection<
         session.connectionStatusChanged.connect(this.onConnectionStatusChanged, this);
         session.iopubMessage.connect(this.onIOPubMessage, this);
         session.unhandledMessage.connect(this.onUnhandledMessage, this);
+        session.pendingInput.connect(this.onPendingInput, this);
         session.anyMessage.connect(this.onAnyMessage, this);
 
         this._register({
@@ -80,6 +86,7 @@ export abstract class BaseJupyterSessionConnection<
                 this.session.connectionStatusChanged.disconnect(this.onConnectionStatusChanged, this);
                 this.session.iopubMessage.disconnect(this.onIOPubMessage, this);
                 this.session.unhandledMessage.disconnect(this.onUnhandledMessage, this);
+                this.session.pendingInput.disconnect(this.onPendingInput, this);
                 this.session.anyMessage.disconnect(this.onAnyMessage, this);
             }
         });
@@ -187,6 +194,9 @@ export abstract class BaseJupyterSessionConnection<
     private onAnyMessage(_: unknown, value: Kernel.IAnyMessageArgs) {
         this.anyMessage.emit(value);
     }
+    private onPendingInput(_: unknown, value: boolean) {
+        this.pendingInput.emit(value);
+    }
     public setPath(value: string) {
         return this.session.setPath(value);
     }

src/kernels/common/baseJupyterSessionConnection.ts

@@ -48,6 +48,7 @@ suite('Base Jupyter Session Connection', () => {
         when(kernel.status).thenReturn('idle');
         when(kernel.connectionStatus).thenReturn('connected');
         when(kernel.statusChanged).thenReturn(instance(mock<ISignal<Kernel.IKernelConnection, Kernel.Status>>()));
+        when(kernel.pendingInput).thenReturn(instance(mock<ISignal<Kernel.IKernelConnection, boolean>>()));
         when(kernel.iopubMessage).thenReturn(
             instance(
                 mock<ISignal<Kernel.IKernelConnection, KernelMessage.IIOPubMessage<KernelMessage.IOPubMessageType>>>()
@@ -96,6 +97,7 @@ suite('Base Jupyter Session Connection', () => {
         when(session.statusChanged).thenReturn(
             new Signal<Session.ISessionConnection, Kernel.Status>(instance(session))
         );
+        when(session.pendingInput).thenReturn(instance(mock<ISignal<Session.ISessionConnection, boolean>>()));
         when(session.unhandledMessage).thenReturn(sessionUnhandledMessage);
         when(session.connectionStatusChanged).thenReturn(sessionConnectionStatusChanged);
         when(session.anyMessage).thenReturn(sessionAnyMessage);

src/kernels/common/baseJupyterSessionConnection.unit.test.ts

@@ -848,7 +848,8 @@ export class CellExecutionMessageHandler implements IDisposable {
                     cancelToken.token
                 )
                 .then((v) => {
-                    this.kernel.sendInputReply({ value: v || '', status: 'ok' });
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    this.kernel.sendInputReply({ value: v || '', status: 'ok' }, msg.header as any);
                 }, noop);
 
             this.prompts.delete(cancelToken);

src/kernels/execution/cellExecutionMessageHandler.ts

@@ -206,13 +206,15 @@ suite('New Jupyter Kernel Session Factory', () => {
         when(session.statusChanged).thenReturn(
             new Signal<Session.ISessionConnection, Kernel.Status>(instance(session))
         );
+        when(session.pendingInput).thenReturn(instance(mock<ISignal<Session.ISessionConnection, boolean>>()));
         when(session.unhandledMessage).thenReturn(sessionUnhandledMessage);
         when(session.connectionStatusChanged).thenReturn(sessionConnectionStatusChanged);
         when(session.anyMessage).thenReturn(sessionAnyMessage);
         when(session.isDisposed).thenReturn(false);
         when(kernel.status).thenReturn('idle');
         when(kernel.connectionStatus).thenReturn('connected');
         when(kernel.statusChanged).thenReturn(instance(mock<ISignal<Kernel.IKernelConnection, Kernel.Status>>()));
+        when(kernel.pendingInput).thenReturn(instance(mock<ISignal<Kernel.IKernelConnection, boolean>>()));
         when(kernel.iopubMessage).thenReturn(
             instance(
                 mock<ISignal<Kernel.IKernelConnection, KernelMessage.IIOPubMessage<KernelMessage.IOPubMessageType>>>()

src/kernels/jupyter/session/jupyterKernelSessionFactory.unit.test.ts

@@ -99,11 +99,11 @@ export class JupyterLabHelper extends ObservableDisposable {
 
         const sessions: Session.IModel[] = [];
         const iterator = this.sessionManager.running();
-        let session = iterator.next();
+        let session = iterator.next().value;
 
         while (session) {
             sessions.push(session);
-            session = iterator.next();
+            session = iterator.next().value;
         }
 
         return sessions;

src/kernels/jupyter/session/jupyterLabHelper.ts

@@ -76,6 +76,7 @@ suite('JupyterSession', () => {
         when(session.unhandledMessage).thenReturn(sessionUnhandledMessage);
         when(session.connectionStatusChanged).thenReturn(sessionConnectionStatusChanged);
         when(session.anyMessage).thenReturn(sessionAnyMessage);
+        when(session.pendingInput).thenReturn(instance(mock<ISignal<Session.ISessionConnection, boolean>>()));
         when(session.isDisposed).thenReturn(false);
         when(kernel.status).thenReturn('idle');
         when(kernel.connectionStatus).thenReturn('connected');
@@ -90,6 +91,7 @@ suite('JupyterSession', () => {
             instance(mock<ISignal<Kernel.IKernelConnection, KernelMessage.IMessage<KernelMessage.MessageType>>>())
         );
         when(kernel.disposed).thenReturn(instance(mock<ISignal<Kernel.IKernelConnection, void>>()));
+        when(kernel.pendingInput).thenReturn(instance(mock<ISignal<Kernel.IKernelConnection, boolean>>()));
         when(kernel.connectionStatusChanged).thenReturn(
             instance(mock<ISignal<Kernel.IKernelConnection, Kernel.ConnectionStatus>>())
         );