Exposing session information to kernel

examples/sessions.ipynb

@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Session Manager"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ipylab import JupyterFrontEnd\n",
+    "app = JupyterFrontEnd()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## show all sessions from the global `SessionManager` instance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "app.sessions.list_sessions()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Show current session"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "app.sessions.current_session"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Force update current session\n",
+    "current_session should be updated automatically, you can force a call if you really want to"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "app.sessions.get_current_session()\n",
+    "app.sessions.current_session"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

ipylab/jupyterfrontend.py

@@ -12,6 +12,7 @@
 
 from .commands import CommandRegistry
 from .shell import Shell
+from .sessions import SessionManager
 
 
 @register
@@ -23,9 +24,16 @@ class JupyterFrontEnd(Widget):
     version = Unicode(read_only=True).tag(sync=True)
     shell = Instance(Shell).tag(sync=True, **widget_serialization)
     commands = Instance(CommandRegistry).tag(sync=True, **widget_serialization)
+    sessions = Instance(SessionManager).tag(sync=True, **widget_serialization)
 
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, shell=Shell(), commands=CommandRegistry(), **kwargs)
+        super().__init__(
+            *args,
+            shell=Shell(),
+            commands=CommandRegistry(),
+            sessions=SessionManager(),
+            **kwargs
+        )
         self._ready_event = asyncio.Event()
         self._on_ready_callbacks = CallbackDispatcher()
         self.on_msg(self._on_frontend_msg)

ipylab/sessions.py

@@ -0,0 +1,77 @@
+'''Expose current and all sessions to python kernel
+'''
+
+from ipywidgets import Widget, register, widget_serialization
+from traitlets import List, Unicode, Bool, Instance, HasTraits, Dict
+
+from ._frontend import module_name, module_version
+
+
+def _noop():
+    pass
+
+
+class Kernel(HasTraits):
+    '''Maps Kernel.IModel
+
+    TODO: Not Used Currently
+    '''
+    _id = Unicode(readonly=True)
+    name = Unicode(readonly=True)
+
+
+class KernelPreference(HasTraits):
+    '''Maps ISessionContext.IKernelPreference
+
+    TODO: Not Used Currently
+    '''
+    _id = Unicode(read_only=True)
+    name = Unicode(read_only=True)
+    language = Unicode(read_only=True)
+    shouldStart = Bool(True, read_only=True)
+    canStart = Bool(True, read_only=True)
+    shutdownOnDispose = Bool(False, read_only=True)
+    autoStartDefault = Bool(True, read_only=True)
+
+
+class SessionContext(HasTraits):
+    '''Partially Map @jupyterlab/apputils SessionContext.IOptions
+
+    TODO: Not Used Currently
+    '''
+    path = Unicode(read_only=True)
+    basePath = Unicode(read_only=True)
+    name = Unicode(read_only=True)
+    kernelPreference = Instance(KernelPreference).tag(**widget_serialization)
+
+
+class Session(HasTraits):
+    '''Maps @jupyterlab/services Session.IModel
+
+    TODO: Not Used Currently
+    '''
+    _id = Unicode(readonly=True)
+    name = Unicode(readonly=True)
+    path = Unicode(readonly=True)
+    _type = Unicode(readonly=True)
+    kernel = Instance(Kernel).tag(**widget_serialization)
+
+
+@register
+class SessionManager(Widget):
+    '''Expose JupyterFrontEnd.serviceManager.sessions'''
+    _model_name = Unicode("SessionManagerModel").tag(sync=True)
+    _model_module = Unicode(module_name).tag(sync=True)
+    _model_module_version = Unicode(module_version).tag(sync=True)
+
+    # keeps track of alist of sessions
+    current_session = Dict(read_only=True).tag(sync=True)
+    sessions = List([], read_only=True).tag(sync=True)
+
+    def get_current_session(self):
+        '''Force a call to update current session'''
+        self.send({"func":"get_current"})
+
+    def list_sessions(self):
+        '''List all running sessions managed in the manager'''
+        return self.sessions

src/plugin.ts

@@ -9,6 +9,8 @@ import {
 
 import { ICommandPalette } from '@jupyterlab/apputils';
 
+import { FocusTracker } from '@lumino/widgets';
+
 import { IJupyterWidgetRegistry } from '@jupyter-widgets/base';
 
 import * as widgetExports from './widget';
@@ -36,6 +38,9 @@ const extension: JupyterFrontEndPlugin<void> = {
     widgetExports.ShellModel.shell = shell;
     widgetExports.CommandRegistryModel.commands = app.commands;
     widgetExports.CommandPaletteModel.palette = palette;
+    widgetExports.SessionManagerModel.sessions = app.serviceManager.sessions;
+    const focusTracker: FocusTracker<any> = (app.shell as any)._tracker;
+    widgetExports.SessionManagerModel.tracker = focusTracker;
 
     registry.registerWidget({
       name: MODULE_NAME,

src/widget.ts

@@ -6,6 +6,7 @@ import '../css/widget.css';
 
 import { CommandRegistryModel } from './widgets/commands';
 import { CommandPaletteModel } from './widgets/palette';
+import { SessionManagerModel } from './widgets/sessions';
 import { JupyterFrontEndModel } from './widgets/frontend';
 import { PanelModel } from './widgets/panel';
 import { ShellModel } from './widgets/shell';
@@ -21,4 +22,5 @@ export {
   SplitPanelModel,
   SplitPanelView,
   TitleModel,
+  SessionManagerModel,
 };

src/widgets/sessions.ts

@@ -0,0 +1,131 @@
+// SessionManager exposes `JupyterLab.serviceManager.sessions` to user python kernel
+
+import { SessionManager } from '@jupyterlab/services';
+import { ISerializers, WidgetModel } from '@jupyter-widgets/base';
+import { toArray } from '@lumino/algorithm';
+import { FocusTracker } from '@lumino/widgets';
+import { MODULE_NAME, MODULE_VERSION } from '../version';
+import { Session } from '@jupyterlab/services';
+
+/**
+ * The model for a Session Manager
+ */
+export class SessionManagerModel extends WidgetModel {
+  /**
+   * The default attributes.
+   */
+  defaults(): any {
+    return {
+      ...super.defaults(),
+      _model_name: SessionManagerModel.model_name,
+      _model_module: SessionManagerModel.model_module,
+      _model_module_version: SessionManagerModel.model_module_version,
+      current_session: null,
+      sessions: [],
+    };
+  }
+
+  /**
+   * Initialize a CommandRegistryModel instance.
+   *
+   * @param attributes The base attributes.
+   * @param options The initialization options.
+   */
+  initialize(attributes: any, options: any): void {
+    this._sessions = SessionManagerModel.sessions;
+    this._tracker = SessionManagerModel.tracker;
+    super.initialize(attributes, options);
+    this.on('msg:custom', this._onMessage.bind(this));
+    this._sessions.runningChanged.connect(this._sendSessions, this);
+    this._tracker.currentChanged.connect(this._currentChanged, this);
+    this._tracker.activeChanged.connect(this._currentChanged, this);
+    this._sendSessions();
+    this._sendCurrent();
+  }
+
+  /**
+   * Handle a custom message from the backend.
+   *
+   * @param msg The message to handle.
+   */
+  private _onMessage(msg: any): void {
+    switch (msg.func) {
+      case 'get_current':
+        this._sendCurrent();
+        break;
+      default:
+        break;
+    }
+  }
+
+  /**
+   * get sessionContext from a given widget instance
+   *
+   * @param widget widget tracked by app.shell._track (FocusTracker)
+   */
+  private _getSessionContext(widget: any): Session.IModel | {} {
+    if (widget?.sessionContext) {
+      // covers both ConsolePanel and NotebookPanle
+      if (widget.sessionContext.session?.model) {
+        return widget.sessionContext.session.model;
+      }
+    }
+    return {}; // empty object serializes to empty dict in python
+  }
+
+  /**
+   * Handle focus change in JLab
+   *
+   * NOTE: currentChange fires on two situations that we are concerned about here:
+   * 1. when user focuses on a widget in browser, which the `change.newValue` will
+   *  be the current Widget
+   * 2. when user executes a code in console/notebook, where the `changed.newValue` will be null since
+   *  we lost focus due to execution.
+   * To solve this problem, we interrogate `this._tracker.currentWidget` directly.
+   * We also added a simple fencing to reduce the number of Comm sync calls between Python/JS
+   */
+  private _currentChanged(): void {
+    this._current_session = this._getSessionContext(
+      this._tracker.currentWidget
+    );
+    this.set('current_session', this._current_session);
+    this.set('sessions', toArray(this._sessions.running()));
+    this.save_changes();
+  }
+
+  /**
+   * Send the list of commands to the backend.
+   */
+  private _sendSessions(): void {
+    this.set('sessions', toArray(this._sessions.running()));
+    this.save_changes();
+  }
+
+  /**
+   * send current session to backend
+   */
+  private _sendCurrent(): void {
+    this._current_session = this._getSessionContext(
+      this._tracker.currentWidget
+    );
+    this.set('current_session', this._current_session);
+    this.save_changes();
+  }
+
+  static serializers: ISerializers = {
+    ...WidgetModel.serializers,
+  };
+
+  static model_name = 'SessionManagerModel';
+  static model_module = MODULE_NAME;
+  static model_module_version = MODULE_VERSION;
+  static view_name: string = null;
+  static view_module: string = null;
+  static view_module_version = MODULE_VERSION;
+
+  private _current_session: Session.IModel | {};
+  private _sessions: SessionManager;
+  static sessions: SessionManager;
+  private _tracker: FocusTracker<any>;
+  static tracker: FocusTracker<any>;
+}