use one-off notification widget for match notification

when no exact match, and only one kernel matches language

IPython/html/static/notebook/js/kernelselector.js

@@ -1,318 +1,324 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'jquery',
     'base/js/namespace',
     'base/js/dialog',
     'base/js/utils',
 ], function($, IPython, dialog, utils) {
     "use strict";
     
     var KernelSelector = function(selector, notebook) {
         var that = this;
         this.selector = selector;
         this.notebook = notebook;
         this.notebook.set_kernelselector(this);
         this.events = notebook.events;
         this.current_selection = null;
         this.kernelspecs = {};
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.request_kernelspecs();
         }
         this.bind_events();
         // Make the object globally available for user convenience & inspection
         IPython.kernelselector = this;
         this._finish_load = null;
         this._loaded = false;
         this.loaded = new Promise(function(resolve) {
             that._finish_load = resolve;
         });
         
         Object.seal(this);
     };
     
     KernelSelector.prototype.request_kernelspecs = function() {
         var url = utils.url_join_encode(this.notebook.base_url, 'api/kernelspecs');
         utils.promising_ajax(url).then($.proxy(this._got_kernelspecs, this));
     };
     
     var _sorted_names = function(kernelspecs) {
         // sort kernel names
         return Object.keys(kernelspecs).sort(function (a, b) {
             // sort by display_name
             var da = kernelspecs[a].spec.display_name;
             var db = kernelspecs[b].spec.display_name;
             if (da === db) {
                 return 0;
             } else if (da > db) {
                 return 1;
             } else {
                 return -1;
             }
         });
     };
     
     KernelSelector.prototype._got_kernelspecs = function(data) {
         var that = this;
         this.kernelspecs = data.kernelspecs;
         var change_kernel_submenu = $("#menu-change-kernel-submenu");
         var new_notebook_submenu = $("#menu-new-notebook-submenu");
         var keys = _sorted_names(data.kernelspecs);
         
         keys.map(function (key) {
             // Create the Kernel > Change kernel submenu
             var ks = data.kernelspecs[key];
             change_kernel_submenu.append(
                 $("<li>").attr("id", "kernel-submenu-"+ks.name).append(
                     $('<a>')
                         .attr('href', '#')
                         .click( function () {
                             that.set_kernel(ks.name);
                         })
                         .text(ks.spec.display_name)
                 )
             );
             // Create the File > New Notebook submenu
             new_notebook_submenu.append(
                 $("<li>").attr("id", "new-notebook-submenu-"+ks.name).append(
                     $('<a>')
                         .attr('href', '#')
                         .click( function () {
                             that.new_notebook(ks.name);
                         })
                         .text(ks.spec.display_name)
                 )
             );
 
         });
         // trigger loaded promise
         this._loaded = true;
         this._finish_load();
     };
     
     KernelSelector.prototype._spec_changed = function (event, ks) {
         /** event handler for spec_changed */
         
         // update selection
         this.current_selection = ks.name;
         
         // put the current kernel at the top of File > New Notebook
         var cur_kernel_entry = $("#new-notebook-submenu-" + ks.name);
         var parent = cur_kernel_entry.parent();
         // do something only if there is more than one kernel
         if (parent.children().length > 1) {
             // first, sort back the submenu
             parent.append(
                 parent.children("li[class!='divider']").sort(
                     function (a,b) {
                         var da = $("a",a).text();
                         var db = $("a",b).text();
                         if (da === db) {
                             return 0;
                         } else if (da > db) {
                             return 1;
                         } else {
                             return -1;
                         }}));
             // then, if there is no divider yet, add one
             if (!parent.children("li[class='divider']").length) {
                 parent.prepend($("<li>").attr("class","divider"));
             } 
             // finally, put the current kernel at the top
             parent.prepend(cur_kernel_entry);
         }
         
         // load logo
         var logo_img = this.element.find("img.current_kernel_logo");
         $("#kernel_indicator").find('.kernel_indicator_name').text(ks.spec.display_name);
         if (ks.resources['logo-64x64']) {
             logo_img.attr("src", ks.resources['logo-64x64']);
             logo_img.show();
         } else {
             logo_img.hide();
         }
         
         // load kernel css
         var css_url = ks.resources['kernel.css'];
         if (css_url) {
             $('#kernel-css').attr('href', css_url);
         } else {
             $('#kernel-css').attr('href', '');
         }
         
         // load kernel js
         if (ks.resources['kernel.js']) {
             require([ks.resources['kernel.js']],
                 function (kernel_mod) {
                     if (kernel_mod && kernel_mod.onload) {
                         kernel_mod.onload();
                     } else {
                         console.warn("Kernel " + ks.name + " has a kernel.js file that does not contain "+
                                      "any asynchronous module definition. This is undefined behavior "+
                                      "and not recommended.");
                     }
                 }, function (err) {
                     console.warn("Failed to load kernel.js from ", ks.resources['kernel.js'], err);
                 }
             );
         }
     };
 
     KernelSelector.prototype.set_kernel = function (selected) {
         /** set the kernel by name, ensuring kernelspecs have been loaded, first 
         
         kernel can be just a kernel name, or a notebook kernelspec metadata
         (name, language, display_name).
         */
         var that = this;
         if (typeof selected === 'string') {
             selected = {
                 name: selected
             };
         }
         if (this._loaded) {
             this._set_kernel(selected);
         } else {
             return this.loaded.then(function () {
                 that._set_kernel(selected);
             });
         }
     };
 
     KernelSelector.prototype._set_kernel = function (selected) {
         /** Actually set the kernel (kernelspecs have been loaded) */
         if (selected.name === this.current_selection) {
             // only trigger event if value changed
             return;
         }
         var kernelspecs = this.kernelspecs;
         var ks = kernelspecs[selected.name];
         if (ks === undefined) {
             var available = _sorted_names(kernelspecs);
             var matches = [];
             if (selected.language && selected.language.length > 0) {
                 available.map(function (name) {
                     if (kernelspecs[name].spec.language.toLowerCase() === selected.language.toLowerCase()) {
                         matches.push(name);
                     }
                 });
             }
             if (matches.length === 1) {
                 ks = kernelspecs[matches[0]];
+                console.log("No exact match found for " + selected.name +
+                    ", using only kernel that matches language=" + selected.language, ks);
+                this.events.trigger("spec_match_found.Kernel", {
+                    selected: selected,
+                    found: ks,
+                });
             }
             // if still undefined, trigger failure event
             if (ks === undefined) {
                 this.events.trigger("spec_not_found.Kernel", {
                     selected: selected,
                     matches: matches,
                     available: available,
                 });
                 return;
             }
         }
         if (this.notebook._session_starting) {
             console.error("Cannot change kernel while waiting for pending session start.");
             return;
         }
         this.current_selection = ks.name;
         this.events.trigger('spec_changed.Kernel', ks);
     };
     
     KernelSelector.prototype._spec_not_found = function (event, data) {
         var that = this;
         var select = $("<select>").addClass('form-control');
         console.warn("Kernelspec not found:", data);
         var names;
         if (data.matches.length > 1) {
             names = data.matches;
         } else {
             names = data.available;
         }
         names.map(function (name) {
             var ks = that.kernelspecs[name];
             select.append(
                 $('<option/>').attr('value', ks.name).text(ks.spec.display_name || ks.name)
             );
         });
         
         var body = $("<form>").addClass("form-inline").append(
             $("<span>").text(
                 "I couldn't find a kernel matching " + (data.selected.display_name || data.name) + "." +
                 " Please select a kernel:"
             )
         ).append(select);
         
         dialog.modal({
             title : 'Kernel not found',
             body : body,
             buttons : {
                 'Continue without kernel' : {
                     class : 'btn-danger',
                     click : function () {
                         that.events.trigger('no_kernel.Kernel');
                     }
                 },
                 OK : {
                     class : 'btn-primary',
                     click : function () {
                         that.set_kernel(select.val());
                     }
                 }
             }
         });
     };
 
     KernelSelector.prototype.new_notebook = function (kernel_name) {
         
         var w = window.open();
         // Create a new notebook in the same path as the current
         // notebook's path.
         var that = this;
         var parent = utils.url_path_split(that.notebook.notebook_path)[0];
         that.notebook.contents.new_untitled(parent, {type: "notebook"}).then(
             function (data) {
                 var url = utils.url_join_encode(
                     that.notebook.base_url, 'notebooks', data.path
                 );
                 url += "?kernel_name=" + kernel_name;
                 w.location = url;
             },
             function(error) {
                 w.close();
                 dialog.modal({
                     title : 'Creating Notebook Failed',
                     body : "The error was: " + error.message,
                     buttons : {'OK' : {'class' : 'btn-primary'}}
                 });
             }
         );
     };
 
     KernelSelector.prototype.lock_switch = function() {
         // should set a flag and display warning+reload if user want to
         // re-change kernel. As UI discussion never finish
         // making that a separate PR.
         console.warn('switching kernel is not guaranteed to work !');
     };
 
     KernelSelector.prototype.bind_events = function() {
         var that = this;
         this.events.on('spec_changed.Kernel', $.proxy(this._spec_changed, this));
         this.events.on('spec_not_found.Kernel', $.proxy(this._spec_not_found, this));
         this.events.on('kernel_created.Session', function (event, data) {
             that.set_kernel(data.kernel.name);
         });
         
         var logo_img = this.element.find("img.current_kernel_logo");
         logo_img.on("load", function() {
             logo_img.show();
         });
         logo_img.on("error", function() {
             logo_img.hide();
         });
     };
 
     return {'KernelSelector': KernelSelector};
 });

IPython/html/static/notebook/js/notificationarea.js

@@ -1,330 +1,337 b''
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'base/js/dialog',
     'base/js/notificationarea',
     'moment'
 ], function(IPython, $, utils, dialog, notificationarea, moment) {
     "use strict";
     var NotificationArea = notificationarea.NotificationArea;
     
     var NotebookNotificationArea = function(selector, options) {
         NotificationArea.apply(this, [selector, options]);
         this.save_widget = options.save_widget;
         this.notebook = options.notebook;
         this.keyboard_manager = options.keyboard_manager;
-    }
+    };
     
     NotebookNotificationArea.prototype = Object.create(NotificationArea.prototype);
     
     /**
      * Initialize the default set of notification widgets.
      *
      * @method init_notification_widgets
      */
     NotebookNotificationArea.prototype.init_notification_widgets = function () {
         this.init_kernel_notification_widget();
         this.init_notebook_notification_widget();
     };
 
     /**
      * Initialize the notification widget for kernel status messages.
      *
      * @method init_kernel_notification_widget
      */
     NotebookNotificationArea.prototype.init_kernel_notification_widget = function () {
         var that = this;
         var knw = this.new_notification_widget('kernel');
         var $kernel_ind_icon = $("#kernel_indicator_icon");
         var $modal_ind_icon = $("#modal_indicator");
-        var $body = $('body')
+        var $body = $('body');
 
         // Command/Edit mode
         this.events.on('edit_mode.Notebook', function () {
             that.save_widget.update_document_title();
             $body.addClass('edit_mode');
             $body.removeClass('command_mode');
             $modal_ind_icon.attr('title','Edit Mode');
         });
 
         this.events.on('command_mode.Notebook', function () {
             that.save_widget.update_document_title();
             $body.removeClass('edit_mode');
             $body.addClass('command_mode');
             $modal_ind_icon.attr('title','Command Mode');
         });
 
         // Implicitly start off in Command mode, switching to Edit mode will trigger event
         $modal_ind_icon.addClass('modal_indicator').attr('title','Command Mode');
-        $body.addClass('command_mode')
+        $body.addClass('command_mode');
 
-        // Kernel events 
+        // Kernel events
 
         // this can be either kernel_created.Kernel or kernel_created.Session
         this.events.on('kernel_created.Kernel kernel_created.Session', function () {
             knw.info("Kernel Created", 500);
         });
 
         this.events.on('kernel_reconnecting.Kernel', function () {
             knw.warning("Connecting to kernel");
         });
 
         this.events.on('kernel_connection_dead.Kernel', function (evt, info) {
             knw.danger("Not Connected", undefined, function () {
                 // schedule reconnect a short time in the future, don't reconnect immediately
                 setTimeout($.proxy(info.kernel.reconnect, info.kernel), 500);
             }, {title: 'click to reconnect'});
         });
 
         this.events.on('kernel_connected.Kernel', function () {
             knw.info("Connected", 500);
         });
 
         this.events.on('kernel_restarting.Kernel', function () {
             that.save_widget.update_document_title();
             knw.set_message("Restarting kernel", 2000);
         });
 
         this.events.on('kernel_autorestarting.Kernel', function (evt, info) {
             // Only show the dialog on the first restart attempt. This
             // number gets tracked by the `Kernel` object and passed
             // along here, because we don't want to show the user 5
             // dialogs saying the same thing (which is the number of
             // times it tries restarting).
             if (info.attempt === 1) {
 
                 dialog.kernel_modal({
                     notebook: that.notebook,
                     keyboard_manager: that.keyboard_manager,
                     title: "Kernel Restarting",
                     body: "The kernel appears to have died. It will restart automatically.",
                     buttons: {
                         OK : {
                             class : "btn-primary"
                         }
                     }
                 });
-            };
+            }
 
             that.save_widget.update_document_title();
             knw.danger("Dead kernel");
             $kernel_ind_icon.attr('class','kernel_dead_icon').attr('title','Kernel Dead');
         });
 
         this.events.on('kernel_interrupting.Kernel', function () {
             knw.set_message("Interrupting kernel", 2000);
         });
 
         this.events.on('kernel_disconnected.Kernel', function () {
             $kernel_ind_icon
                 .attr('class', 'kernel_disconnected_icon')
                 .attr('title', 'No Connection to Kernel');
         });
 
         this.events.on('kernel_connection_failed.Kernel', function (evt, info) {
             // only show the dialog if this is the first failed
             // connect attempt, because the kernel will continue
             // trying to reconnect and we don't want to spam the user
             // with messages
             if (info.attempt === 1) {
 
                 var msg = "A connection to the notebook server could not be established." +
                         " The notebook will continue trying to reconnect, but" +
                         " until it does, you will NOT be able to run code. Check your" +
                         " network connection or notebook server configuration.";
 
                 dialog.kernel_modal({
                     title: "Connection failed",
                     body: msg,
                     keyboard_manager: that.keyboard_manager,
                     notebook: that.notebook,
                     buttons : {
                         "OK": {}
                     }
                 });
             }
         });
 
         this.events.on('kernel_killed.Kernel kernel_killed.Session', function () {
             that.save_widget.update_document_title();
             knw.warning("No kernel");
             $kernel_ind_icon.attr('class','kernel_busy_icon').attr('title','Kernel is not running');
         });
 
         this.events.on('kernel_dead.Kernel', function () {
 
             var showMsg = function () {
 
                 var msg = 'The kernel has died, and the automatic restart has failed.' +
                         ' It is possible the kernel cannot be restarted.' +
                         ' If you are not able to restart the kernel, you will still be able to save' +
                         ' the notebook, but running code will no longer work until the notebook' +
                         ' is reopened.';
 
                 dialog.kernel_modal({
                     title: "Dead kernel",
                     body : msg,
                     keyboard_manager: that.keyboard_manager,
                     notebook: that.notebook,
                     buttons : {
                         "Manual Restart": {
                             class: "btn-danger",
                             click: function () {
                                 that.notebook.start_session();
                             }
                         },
                     "Don't restart": {}
                     }
                 });
 
                 return false;
             };
 
             that.save_widget.update_document_title();
             knw.danger("Dead kernel", undefined, showMsg);
             $kernel_ind_icon.attr('class','kernel_dead_icon').attr('title','Kernel Dead');
 
             showMsg();
         });
         
         this.events.on("no_kernel.Kernel", function (evt, data) {
             $("#kernel_indicator").find('.kernel_indicator_name').text("No Kernel");
         });
 
         this.events.on('kernel_dead.Session', function (evt, info) {
             var full = info.xhr.responseJSON.message;
             var short = info.xhr.responseJSON.short_message || 'Kernel error';
             var traceback = info.xhr.responseJSON.traceback;
 
             var showMsg = function () {
                 var msg = $('<div/>').append($('<p/>').text(full));
                 var cm, cm_elem, cm_open;
 
                 if (traceback) {
                     cm_elem = $('<div/>')
                         .css('margin-top', '1em')
                         .css('padding', '1em')
                         .addClass('output_scroll');
                     msg.append(cm_elem);
                     cm = CodeMirror(cm_elem.get(0), {
                         mode:  "python",
                         readOnly : true
                     });
                     cm.setValue(traceback);
                     cm_open = $.proxy(cm.refresh, cm);
                 }
 
                 dialog.kernel_modal({
                     title: "Failed to start the kernel",
                     body : msg,
                     keyboard_manager: that.keyboard_manager,
                     notebook: that.notebook,
                     open: cm_open,
                     buttons : {
                         "Ok": { class: 'btn-primary' }
                     }
                 });
 
                 return false;
             };
 
             that.save_widget.update_document_title();
             $kernel_ind_icon.attr('class','kernel_dead_icon').attr('title','Kernel Dead');
             knw.danger(short, undefined, showMsg);
         });
 
         this.events.on('kernel_starting.Kernel kernel_created.Session', function () {
             window.document.title='(Starting) '+window.document.title;
             $kernel_ind_icon.attr('class','kernel_busy_icon').attr('title','Kernel Busy');
             knw.set_message("Kernel starting, please wait...");
         });
 
         this.events.on('kernel_ready.Kernel', function () {
             that.save_widget.update_document_title();
             $kernel_ind_icon.attr('class','kernel_idle_icon').attr('title','Kernel Idle');
             knw.info("Kernel ready", 500);
         });
 
         this.events.on('kernel_idle.Kernel', function () {
             that.save_widget.update_document_title();
             $kernel_ind_icon.attr('class','kernel_idle_icon').attr('title','Kernel Idle');
         });
 
         this.events.on('kernel_busy.Kernel', function () {
             window.document.title='(Busy) '+window.document.title;
             $kernel_ind_icon.attr('class','kernel_busy_icon').attr('title','Kernel Busy');
         });
+
+        this.events.on('spec_match_found.Kernel', function (evt, data) {
+            that.widget('kernelspec').info("Using kernel: " + data.found.spec.display_name, 3000, undefined, {
+                title: "Only candidate for language: " + data.selected.language + " was " + data.found.spec.display_name
+            });
+        });
+
         
         // Start the kernel indicator in the busy state, and send a kernel_info request.
         // When the kernel_info reply arrives, the kernel is idle.
         $kernel_ind_icon.attr('class','kernel_busy_icon').attr('title','Kernel Busy');
     };
 
     /**
      * Initialize the notification widget for notebook status messages.
      *
      * @method init_notebook_notification_widget
      */
     NotebookNotificationArea.prototype.init_notebook_notification_widget = function () {
         var nnw = this.new_notification_widget('notebook');
 
         // Notebook events
         this.events.on('notebook_loading.Notebook', function () {
             nnw.set_message("Loading notebook",500);
         });
         this.events.on('notebook_loaded.Notebook', function () {
             nnw.set_message("Notebook loaded",500);
         });
         this.events.on('notebook_saving.Notebook', function () {
             nnw.set_message("Saving notebook",500);
         });
         this.events.on('notebook_saved.Notebook', function () {
             nnw.set_message("Notebook saved",2000);
         });
         this.events.on('notebook_save_failed.Notebook', function (evt, error) {
             nnw.warning(error.message || "Notebook save failed");
         });
         this.events.on('notebook_copy_failed.Notebook', function (evt, error) {
             nnw.warning(error.message || "Notebook copy failed");
         });
         
         // Checkpoint events
         this.events.on('checkpoint_created.Notebook', function (evt, data) {
             var msg = "Checkpoint created";
             if (data.last_modified) {
                 var d = new Date(data.last_modified);
                 msg = msg + ": " + moment(d).format("HH:mm:ss");
             }
             nnw.set_message(msg, 2000);
         });
         this.events.on('checkpoint_failed.Notebook', function () {
             nnw.warning("Checkpoint failed");
         });
         this.events.on('checkpoint_deleted.Notebook', function () {
             nnw.set_message("Checkpoint deleted", 500);
         });
         this.events.on('checkpoint_delete_failed.Notebook', function () {
             nnw.warning("Checkpoint delete failed");
         });
         this.events.on('checkpoint_restoring.Notebook', function () {
             nnw.set_message("Restoring to checkpoint...", 500);
         });
         this.events.on('checkpoint_restore_failed.Notebook', function () {
             nnw.warning("Checkpoint restore failed");
         });
 
         // Autosave events
         this.events.on('autosave_disabled.Notebook', function () {
             nnw.set_message("Autosave disabled", 2000);
         });
         this.events.on('autosave_enabled.Notebook', function (evt, interval) {
             nnw.set_message("Saving every " + interval / 1000 + "s", 1000);
         });
     };
 
     // Backwards compatibility.
     IPython.NotificationArea = NotebookNotificationArea;
     
     return {'NotebookNotificationArea': NotebookNotificationArea};
 });