Make the LSP completions work when kernel is busy or slow

Author: krassowski

README.md

@@ -54,9 +54,14 @@ Advanced static-analysis autocompletion without a running kernel
 
 ![autocompletion](https://raw.githubusercontent.com/krassowski/jupyterlab-lsp/master/examples/screenshots/autocompletion.png)
 
-> When a kernel is available the suggestions from the kernel (such as keys of a
-> dict and columns of a DataFrame autocompletion) are merged with the suggestions
-> from the Language Server (currently only in notebook).
+#### The runtime kernel suggestions are still there
+
+When a kernel is available the suggestions from the kernel (such as keys of a
+dict and columns of a DataFrame autocompletion) are merged with the suggestions
+from the Language Server (currently only in notebook).
+
+If the kernel is too slow to respond promptly only the LSP static analysis suggestions will be shown (default threshold: 0.6s).
+You can configure the completer to not attempt to fetch the kernel completions if the kernel is busy (skipping the 0.6s timeout).
 
 ### Rename
 

atest/05_Features/Completion.robot

@@ -8,9 +8,10 @@ Resource          ../Keywords.robot
 *** Variables ***
 ${COMPLETER_BOX}    css:.jp-Completer.jp-HoverBox
 ${DOCUMENTATION_PANEL}    css:.jp-Completer-docpanel
+${KERNEL_BUSY_INDICATOR}    css:.jp-NotebookPanel-toolbar div[title="Kernel Busy"]
 
 *** Test Cases ***
-Works With Kernel Running
+Works With Kernel Is Idle
     [Documentation]    The suggestions from kernel and LSP should get integrated.
     Enter Cell Editor    1    line=2
     Capture Page Screenshot    01-entered-cell.png
@@ -27,6 +28,15 @@ Works With Kernel Running
     ${content} =    Get Cell Editor Content    1
     Should Contain    ${content}    TabError
 
+Uses LSP Completions When Kernel Resoponse Times Out
+    Configure JupyterLab Plugin    {"kernelResponseTimeout": 1, "waitForKernelIfBusy": true}    plugin id=${COMPLETION PLUGIN ID}
+    Should Complete While Kernel Is Busy
+
+Uses LSP Completions When Kernel Is Busy
+    [Documentation]    When kernel is not available the best thing is to show some suggestions (LSP) rather than none.
+    Configure JupyterLab Plugin    {"kernelResponseTimeout": -1, "waitForKernelIfBusy": false}    plugin id=${COMPLETION PLUGIN ID}
+    Should Complete While Kernel Is Busy
+
 Works When Kernel Is Shut Down
     Lab Command    Shut Down All Kernels…
     Wait For Dialog
@@ -42,9 +52,7 @@ Works When Kernel Is Shut Down
     Completer Should Not Suggest    %%timeit
 
 Works After Kernel Restart In New Cells
-    Lab Command    Restart Kernel…
-    Wait For Dialog
-    Accept Default Dialog Option
+    Restart Kernel
     Enter Cell Editor    1    line=2
     # works in old cells
     Trigger Completer
@@ -290,3 +298,29 @@ Completer Should Include Documentation
     [Arguments]    ${text}
     Wait Until Page Contains Element    ${DOCUMENTATION_PANEL}    timeout=10s
     Element Should Contain    ${DOCUMENTATION_PANEL}    ${text}
+
+Restart Kernel
+    Lab Command    Restart Kernel…
+    Wait For Dialog
+    Accept Default Dialog Option
+
+Count Completer Hints
+    ${count} =    Get Element Count    css:.jp-Completer-item
+    [Return]    ${count}
+
+Should Complete While Kernel Is Busy
+    # Run the cell with sleep(10)
+    Enter Cell Editor    17
+    # for some reason the lab command selects another cell along the way...
+    # Lab Command    Run Selected Cells And Don't Advance
+    Press Keys    None    CTRL+ENTER
+    # Confirm that the kernel is busy
+    Wait Until Page Contains Element    ${KERNEL_BUSY_INDICATOR}    timeout=3s
+    # Enter a cell with "t"
+    Enter Cell Editor    18
+    # Check if completion worked
+    Enter Cell Editor    1    line=2
+    Trigger Completer    timeout=3s
+    Completer Should Suggest    test    timeout=3s
+    # Confirm that the kernel indicator was busy all along
+    Page Should Contain Element    ${KERNEL_BUSY_INDICATOR}

atest/examples/Completion.ipynb

@@ -124,6 +124,32 @@
    "source": [
     "import os.pat"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "LSP completion works when kernel is busy:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from time import sleep\n",
+    "sleep(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t"
+   ]
   }
  ],
  "metadata": {

packages/jupyterlab-lsp/schema/completion.json

@@ -24,7 +24,19 @@
         "type": "string"
       },
       "default": ["comment", "string"],
-      "description": "An array of CodeMirror tokens for which the auto-invoke should be suppressed. The token names vary between languages (modes)."
+      "description": "An array of CodeMirror tokens for which the auto-invoke should be suppressed. Adding 'def' will prevent continuous hinting when writing a function name in Python, Julia, JavaScript and other languages. The token names vary between languages (modes)."
+    },
+    "kernelResponseTimeout": {
+      "title": "Kernel completion response timeout",
+      "default": 600,
+      "type": "number",
+      "description": "The time to wait for the kernel completions suggestions in milliseconds. Set to 0 to disable kernel completions, or to -1 to wait indefinitely (not recommended)."
+    },
+    "waitForBusyKernel": {
+      "title": "Wait for kernel if busy",
+      "default": true,
+      "type": "boolean",
+      "description": "Should an attempt to get the kernel response (with timeout as specified by kernelResponseTimeout) be made if kernel is busy? If you often write code in notebook while computations are running for long time (e.g. training models), turning this off might give you faster response times."
     },
     "theme": {
       "title": "Completer theme",

packages/jupyterlab-lsp/src/features/completion/completion_handler.ts

@@ -242,10 +242,22 @@ export class LSPConnector
     return this.options.session?.kernel != null;
   }
 
+  protected get _is_kernel_idle(): boolean {
+    return this.options.session?.kernel?.status == 'idle';
+  }
+
+  protected get _should_wait_for_busy_kernel(): boolean {
+    return this.lab_integration.settings.composite.waitForBusyKernel;
+  }
+
   protected async _kernel_language(): Promise<string> {
     return (await this.options.session.kernel.info).language_info.name;
   }
 
+  protected get _kernel_timeout(): number {
+    return this.lab_integration.settings.composite.kernelResponseTimeout;
+  }
+
   get fallback_connector() {
     return this._kernel_and_context_connector
       ? this._kernel_and_context_connector
@@ -319,7 +331,14 @@ export class LSPConnector
     let promise: Promise<CompletionHandler.ICompletionItemsReply> = null;
 
     try {
-      if (this._kernel_connector && this._has_kernel) {
+      const kernelTimeout = this._kernel_timeout;
+
+      if (
+        this._kernel_connector &&
+        this._has_kernel &&
+        (this._is_kernel_idle || this._should_wait_for_busy_kernel) &&
+        kernelTimeout != 0
+      ) {
         // TODO: this would be awesome if we could connect to rpy2 for R suggestions in Python,
         //  but this is not the job of this extension; nevertheless its better to keep this in
         //  mind to avoid introducing design decisions which would make this impossible
@@ -329,8 +348,36 @@ export class LSPConnector
         const kernelLanguage = await this._kernel_language();
 
         if (document.language === kernelLanguage) {
+          let default_kernel_promise = this._kernel_connector.fetch(request);
+          let kernel_promise: Promise<CompletionHandler.IReply>;
+
+          if (kernelTimeout == -1) {
+            kernel_promise = default_kernel_promise;
+          } else {
+            // implement timeout for the kernel response using Promise.race:
+            // an empty completion result will resolve after the timeout
+            // if actual kernel response does not beat it to it
+            kernel_promise = Promise.race([
+              default_kernel_promise,
+              new Promise<CompletionHandler.IReply>(resolve => {
+                return setTimeout(
+                  () =>
+                    resolve({
+                      start: null,
+                      end: null,
+                      matches: [],
+                      metadata: null
+                    }),
+                  kernelTimeout
+                );
+              })
+            ]);
+          }
+
+          // TODO: use allSettled if available; requires ES2020 or a polyfill
+          // allSettled ensures that the result is not lost if one of the promises rejects
           promise = Promise.all([
-            this._kernel_connector.fetch(request),
+            kernel_promise,
             lsp_promise
           ]).then(([kernel, lsp]) =>
             this.merge_replies(this.transform_reply(kernel), lsp, this._editor)
@@ -352,6 +399,7 @@ export class LSPConnector
         .then(this.transform_reply);
     }
 
+    this.console.debug('All promises set up and ready.');
     return promise.then(reply => {
       reply = this.suppress_if_needed(reply, token);
       this.items = reply.items;