Changed getWidgetManager to be a static method of KernelWidgetManager and renamed to getManager.

Author: Alan Fleming

packages/base-manager/src/manager-base.ts

@@ -214,10 +214,10 @@ export abstract class ManagerBase implements IWidgetManager {
    *
    * If you would like to synchronously test if a model exists, use .has_model().
    */
-  async get_model(model_id: string): Promise<WidgetModel> {
+  async get_model(model_id: string, delays = [500]): Promise<WidgetModel> {
     let i = 0;
-    while (!this._models[model_id] && i < this._sleepTimes.length) {
-      await new Promise((resolve) => setTimeout(resolve, this._sleepTimes[i++]));
+    while (!this._models[model_id] && i < delays.length) {
+      await new Promise((resolve) => setTimeout(resolve, delays[i++]));
     }
     const modelPromise = this._models[model_id];
     if (modelPromise === undefined) {
@@ -878,7 +878,6 @@ export abstract class ManagerBase implements IWidgetManager {
   /**
    * Dictionary of model ids and model instance promises
    */
-  private _sleepTimes = [2, 50, 200, 800];
   private _models: { [key: string]: Promise<WidgetModel> } =
     Object.create(null);
 }

python/jupyterlab_widgets/src/index.ts

@@ -8,11 +8,7 @@ export default WidgetManagerProvider;
 
 export { registerWidgetManager } from './plugin';
 
-export {
-  KernelWidgetManager,
-  LabWidgetManager,
-  WidgetManager,
-} from './manager';
+export { KernelWidgetManager, WidgetManager } from './manager';
 
 export { WidgetRenderer } from './renderer';
 

python/jupyterlab_widgets/src/manager.ts

@@ -367,7 +367,7 @@ export class KernelWidgetManager extends LabWidgetManager {
     rendermime?: IRenderMimeRegistry,
     pendingManagerMessage = 'Loading widget ...'
   ) {
-    const instance = Private.kernelWidgetManagers.get(kernel.id);
+    const instance = Private.managers.get(kernel.id);
     if (instance) {
       instance._useKernel(kernel);
       KernelWidgetManager.configureRendermime(
@@ -381,7 +381,7 @@ export class KernelWidgetManager extends LabWidgetManager {
       throw new Error('Kernel does not have handleComms enabled');
     }
     super(LabWidgetManager.globalRendermime);
-    Private.kernelWidgetManagers.set(kernel.id, this);
+    Private.managers.set(kernel.id, this);
     this.loadCustomWidgetDefinitions();
     LabWidgetManager.WIDGET_REGISTRY.changed.connect(() =>
       this.loadCustomWidgetDefinitions()
@@ -475,10 +475,30 @@ export class KernelWidgetManager extends LabWidgetManager {
   }
 
   static existsWithActiveKenel(id: string) {
-    const widgetManager = Private.kernelWidgetManagers.get(id);
+    const widgetManager = Private.managers.get(id);
     return !widgetManager?.disconnected;
   }
 
+  /**
+   * Get the KernelWidgetManager that owns the model.
+   */
+  static async getManager(
+    model_id: string,
+    delays = [100, 1000]
+  ): Promise<KernelWidgetManager> {
+    for (const sleepTime of delays) {
+      for (const wManager of Private.managers.values()) {
+        if (wManager.has_model(model_id)) {
+          return wManager;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, sleepTime));
+    }
+    throw new Error(
+      `Failed to locate the KernelWidgetManager for model_id='${model_id}'`
+    );
+  }
+
   _handleKernelStatusChange(
     sender: Kernel.IKernelConnection,
     status: Kernel.Status
@@ -516,7 +536,7 @@ export class KernelWidgetManager extends LabWidgetManager {
     }
     super.dispose();
     KernelWidgetManager.configureRendermime(this.rendermime);
-    Private.kernelWidgetManagers.delete(this.kernel.id);
+    Private.managers.delete(this.kernel.id);
     this._handleKernelChanged({
       name: 'kernel',
       oldValue: this._kernel,
@@ -829,28 +849,12 @@ export namespace WidgetManager {
   };
 }
 
-/**
- * Get the widgetManager that owns the model.
- */
-export async function getWidgetManager(
-  model_id: string
-): Promise<KernelWidgetManager | undefined> {
-  for (const sleepTime of [0, 50, 1000]) {
-    await new Promise((resolve) => setTimeout(resolve, sleepTime));
-    for (const wManager of Private.kernelWidgetManagers.values()) {
-      if (wManager.has_model(model_id)) {
-        return wManager;
-      }
-    }
-  }
-  return undefined;
-}
-
 /**
  * A namespace for private data
  */
 namespace Private {
-  export const kernelWidgetManagers = new Map<string, KernelWidgetManager>();
+  export const managers = new Map<string, KernelWidgetManager>();
+
   export const widgetManagerProperty = new AttachedProperty<
     DocumentRegistry.Context,
     WidgetManager | undefined

python/jupyterlab_widgets/src/renderer.ts

@@ -11,7 +11,7 @@ import { IRenderMime } from '@jupyterlab/rendermime-interfaces';
 
 import { DOMWidgetModel } from '@jupyter-widgets/base';
 
-import { LabWidgetManager, getWidgetManager } from './manager';
+import { KernelWidgetManager } from './manager';
 
 /**
  * A renderer for widgets.
@@ -35,7 +35,7 @@ export class WidgetRenderer
 {
   constructor(
     options: IRenderMime.IRendererOptions,
-    manager?: LabWidgetManager,
+    manager?: KernelWidgetManager,
     pendingManagerMessage = ''
   ) {
     super();
@@ -50,7 +50,7 @@ export class WidgetRenderer
    * Will accept the first non-null manager and ignore anything afterwards.
    */
 
-  set manager(value: LabWidgetManager | undefined) {
+  set manager(value: KernelWidgetManager | undefined) {
     if (value && !this._managerIsSet) {
       // Can only set the manager once
       this._manager.resolve(value);
@@ -68,15 +68,20 @@ export class WidgetRenderer
     // If there is no model id, the view was removed, so hide the node.
     if (source.model_id === '') {
       this.hide();
-      return Promise.resolve();
+      return;
     }
     if (!this._pendingManagerMessage && !this._managerIsSet) {
-      this.manager = await getWidgetManager(source.model_id);
+      try {
+        this.manager = await KernelWidgetManager.getManager(source.model_id);
+      } catch {
+        this.node.textContent = `KernelWidgetManager not found for model: ${model.data['text/plain']}`;
+        return;
+      }
     }
     this.node.textContent = `${
       this._pendingManagerMessage || model.data['text/plain']
     }`;
-    const manager: LabWidgetManager = await this._manager.promise;
+    const manager = await this._manager.promise;
     this._rerenderMimeModel = model;
 
     let wModel: DOMWidgetModel;
@@ -85,15 +90,15 @@ export class WidgetRenderer
       wModel = (await manager.get_model(source.model_id)) as DOMWidgetModel;
     } catch (err) {
       if (this._pendingManagerMessage === 'No kernel') {
-        this.node.textContent = `Model not found for this kernel: ${model.data['text/plain']}`;
+        this.node.textContent = `Model not found: ${model.data['text/plain']}`;
       } else if (manager.restoredStatus) {
         // The manager has been restored, so this error won't be going away.
         this.node.textContent = 'Error displaying widget: model not found';
         this.addClass('jupyter-widgets');
         console.error(err);
       }
       // Store the model for a possible rerender
-      return Promise.resolve();
+      return;
     }
     let widget: LuminoWidget;
     try {
@@ -146,7 +151,7 @@ export class WidgetRenderer
    * The mimetype being rendered.
    */
   readonly mimeType: string;
-  private _manager = new PromiseDelegate<LabWidgetManager>();
+  private _manager = new PromiseDelegate<KernelWidgetManager>();
   private _managerIsSet = false;
   private _pendingManagerMessage: string;
   private _rerenderMimeModel: IRenderMime.IMimeModel | null = null;